image/svg+xml
Brteve's API for EveApps
Version 0.0.1
The reference document for common folder of EveApps project.
 
Loading...
Searching...
No Matches
EVE_HalImpl_MULTI.c
Go to the documentation of this file.
1
32#include "EVE_HalImpl.h"
33#include "EVE_Platform.h"
34#if defined(EVE_MULTI_PLATFORM_TARGET)
35
36static size_t s_TotalDeviceCount = 0;
37static size_t s_DeviceCountBT8XXEMU = 0;
38static size_t s_DeviceCountMPSSE = 0;
39static size_t s_DeviceCountFT4222 = 0;
40
41DWORD g_NumDevsD2XX = 0;
42
43/*********
44** INIT **
45*********/
46
49
50/* Initialize HAL platform */
51void EVE_HalImpl_BT8XXEMU_initialize();
52void EVE_HalImpl_FT4222_initialize();
53void EVE_HalImpl_MPSSE_initialize();
54void EVE_HalImpl_initialize()
55{
56 EVE_HalImpl_BT8XXEMU_initialize();
57 EVE_HalImpl_MPSSE_initialize();
58 EVE_HalImpl_FT4222_initialize();
59}
60
61/* Release HAL platform */
62void EVE_HalImpl_BT8XXEMU_release();
63void EVE_HalImpl_FT4222_release();
64void EVE_HalImpl_MPSSE_release();
65void EVE_HalImpl_release()
66{
67 EVE_HalImpl_FT4222_release();
68 EVE_HalImpl_MPSSE_release();
69 EVE_HalImpl_BT8XXEMU_release();
70}
71
72size_t EVE_Hal_BT8XXEMU_list();
73size_t EVE_Hal_FT4222_list();
74size_t EVE_Hal_MPSSE_list();
75EVE_HAL_EXPORT size_t EVE_Hal_list()
76{
77 s_DeviceCountBT8XXEMU = EVE_Hal_BT8XXEMU_list();
78 s_DeviceCountMPSSE = EVE_Hal_MPSSE_list();
79 s_DeviceCountFT4222 = EVE_Hal_FT4222_list();
80 s_TotalDeviceCount = s_DeviceCountBT8XXEMU + s_DeviceCountMPSSE + s_DeviceCountFT4222;
81 return s_TotalDeviceCount;
82}
83
84void EVE_Hal_BT8XXEMU_info(EVE_DeviceInfo *deviceInfo, size_t deviceIdx);
85void EVE_Hal_FT4222_info(EVE_DeviceInfo *deviceInfo, size_t deviceIdx);
86void EVE_Hal_MPSSE_info(EVE_DeviceInfo *deviceInfo, size_t deviceIdx);
87EVE_HAL_EXPORT void EVE_Hal_info(EVE_DeviceInfo *deviceInfo, size_t deviceIdx)
88{
89 if (deviceIdx < s_DeviceCountBT8XXEMU)
90 {
91 EVE_Hal_BT8XXEMU_info(deviceInfo, deviceIdx);
92 }
93 else if (deviceIdx < s_DeviceCountBT8XXEMU + s_DeviceCountMPSSE)
94 {
95 EVE_Hal_MPSSE_info(deviceInfo, deviceIdx - s_DeviceCountBT8XXEMU);
96 }
97 else if (deviceIdx < s_DeviceCountBT8XXEMU + s_DeviceCountMPSSE + s_DeviceCountFT4222)
98 {
99 EVE_Hal_FT4222_info(deviceInfo, deviceIdx - s_DeviceCountBT8XXEMU - s_DeviceCountMPSSE);
100 }
101 else
102 {
103 memset(deviceInfo, 0, sizeof(EVE_DeviceInfo));
104 }
105}
106
107/* Check whether the context is the specified device */
108bool EVE_Hal_BT8XXEMU_isDevice(EVE_HalContext *phost, size_t deviceIdx);
109bool EVE_Hal_FT4222_isDevice(EVE_HalContext *phost, size_t deviceIdx);
110bool EVE_Hal_MPSSE_isDevice(EVE_HalContext *phost, size_t deviceIdx);
111EVE_HAL_EXPORT bool EVE_Hal_isDevice(EVE_HalContext *phost, size_t deviceIdx)
112{
113 if (deviceIdx < s_DeviceCountBT8XXEMU)
114 {
115 return EVE_Hal_BT8XXEMU_isDevice(phost, deviceIdx);
116 }
117 else if (deviceIdx < s_DeviceCountBT8XXEMU + s_DeviceCountMPSSE)
118 {
119 return EVE_Hal_MPSSE_isDevice(phost, deviceIdx - s_DeviceCountBT8XXEMU);
120 }
121 else
122 {
123 return EVE_Hal_FT4222_isDevice(phost, deviceIdx - s_DeviceCountBT8XXEMU - s_DeviceCountMPSSE);
124 }
125}
126
127/* Get the default configuration parameters */
128bool EVE_HalImpl_BT8XXEMU_defaults(EVE_HalParameters *parameters, size_t deviceIdx);
129bool EVE_HalImpl_FT4222_defaults(EVE_HalParameters *parameters, size_t deviceIdx);
130bool EVE_HalImpl_MPSSE_defaults(EVE_HalParameters *parameters, size_t deviceIdx);
131bool EVE_HalImpl_defaults(EVE_HalParameters *parameters, size_t deviceIdx)
132{
133 bool res;
134 if (deviceIdx < s_DeviceCountBT8XXEMU)
135 {
136 res = EVE_HalImpl_BT8XXEMU_defaults(parameters, deviceIdx);
137 parameters->Host = EVE_HOST_BT8XXEMU;
138 }
139 else if (deviceIdx < s_DeviceCountBT8XXEMU + s_DeviceCountMPSSE)
140 {
141 res = EVE_HalImpl_MPSSE_defaults(parameters, deviceIdx - s_DeviceCountBT8XXEMU);
142 parameters->Host = EVE_HOST_MPSSE;
143 }
144 else if (deviceIdx < s_DeviceCountBT8XXEMU + s_DeviceCountMPSSE + s_DeviceCountFT4222)
145 {
146 res = EVE_HalImpl_FT4222_defaults(parameters, deviceIdx - s_DeviceCountBT8XXEMU - s_DeviceCountMPSSE);
147 parameters->Host = EVE_HOST_FT4222;
148 }
149 else if ((res = EVE_HalImpl_FT4222_defaults(parameters, deviceIdx - s_DeviceCountBT8XXEMU - s_DeviceCountMPSSE)))
150 {
151 parameters->Host = EVE_HOST_FT4222;
152 }
153 else if ((res = EVE_HalImpl_MPSSE_defaults(parameters, deviceIdx - s_DeviceCountBT8XXEMU)))
154 {
155 parameters->Host = EVE_HOST_MPSSE;
156 }
157 else if ((res = EVE_HalImpl_BT8XXEMU_defaults(parameters, deviceIdx)))
158 {
159 parameters->Host = EVE_HOST_BT8XXEMU;
160 }
161 return res;
162}
163
164/* Opens a new HAL context using the specified parameters */
165bool EVE_HalImpl_BT8XXEMU_open(EVE_HalContext *phost, const EVE_HalParameters *parameters);
166bool EVE_HalImpl_FT4222_open(EVE_HalContext *phost, const EVE_HalParameters *parameters);
167bool EVE_HalImpl_MPSSE_open(EVE_HalContext *phost, const EVE_HalParameters *parameters);
168bool EVE_HalImpl_open(EVE_HalContext *phost, const EVE_HalParameters *parameters)
169{
170 bool res;
171 switch (parameters->Host)
172 {
173 case EVE_HOST_BT8XXEMU:
174 res = EVE_HalImpl_BT8XXEMU_open(phost, parameters);
175 break;
176 case EVE_HOST_FT4222:
177 res = EVE_HalImpl_FT4222_open(phost, parameters);
178 break;
179 case EVE_HOST_MPSSE:
180 res = EVE_HalImpl_MPSSE_open(phost, parameters);
181 break;
182 default:
183 res = false;
184 break;
185 }
186 phost->Host = parameters->Host;
187 return res;
188}
189
190/* Close a HAL context */
191void EVE_HalImpl_BT8XXEMU_close(EVE_HalContext *phost);
192void EVE_HalImpl_FT4222_close(EVE_HalContext *phost);
193void EVE_HalImpl_MPSSE_close(EVE_HalContext *phost);
194void EVE_HalImpl_close(EVE_HalContext *phost)
195{
196 switch (phost->Host)
197 {
198 case EVE_HOST_BT8XXEMU:
199 EVE_HalImpl_BT8XXEMU_close(phost);
200 break;
201 case EVE_HOST_FT4222:
202 EVE_HalImpl_FT4222_close(phost);
203 break;
204 case EVE_HOST_MPSSE:
205 EVE_HalImpl_MPSSE_close(phost);
206 break;
207 default:
208 break;
209 }
210}
211
212/* Idle. Call regularly to update frequently changing internal state */
213void EVE_HalImpl_BT8XXEMU_idle(EVE_HalContext *phost);
214void EVE_HalImpl_FT4222_idle(EVE_HalContext *phost);
215void EVE_HalImpl_MPSSE_idle(EVE_HalContext *phost);
216void EVE_HalImpl_idle(EVE_HalContext *phost)
217{
218 switch (phost->Host)
219 {
220 case EVE_HOST_BT8XXEMU:
221 EVE_HalImpl_BT8XXEMU_idle(phost);
222 break;
223 case EVE_HOST_FT4222:
224 EVE_HalImpl_FT4222_idle(phost);
225 break;
226 case EVE_HOST_MPSSE:
227 EVE_HalImpl_MPSSE_idle(phost);
228 break;
229 default:
230 break;
231 }
232}
234
235/*************
236** TRANSFER **
237*************/
238
241
242void EVE_Hal_BT8XXEMU_startTransfer(EVE_HalContext *phost, EVE_TRANSFER_T rw, uint32_t addr);
243void EVE_Hal_FT4222_startTransfer(EVE_HalContext *phost, EVE_TRANSFER_T rw, uint32_t addr);
244void EVE_Hal_MPSSE_startTransfer(EVE_HalContext *phost, EVE_TRANSFER_T rw, uint32_t addr);
245EVE_HAL_EXPORT void EVE_Hal_startTransfer(EVE_HalContext *phost, EVE_TRANSFER_T rw, uint32_t addr)
246{
247 switch (phost->Host)
248 {
249 case EVE_HOST_BT8XXEMU:
250 EVE_Hal_BT8XXEMU_startTransfer(phost, rw, addr);
251 break;
252 case EVE_HOST_FT4222:
253 EVE_Hal_FT4222_startTransfer(phost, rw, addr);
254 break;
255 case EVE_HOST_MPSSE:
256 EVE_Hal_MPSSE_startTransfer(phost, rw, addr);
257 break;
258 default:
259 break;
260 }
261}
262
263void EVE_Hal_BT8XXEMU_endTransfer(EVE_HalContext *phost);
264void EVE_Hal_FT4222_endTransfer(EVE_HalContext *phost);
265void EVE_Hal_MPSSE_endTransfer(EVE_HalContext *phost);
266EVE_HAL_EXPORT void EVE_Hal_endTransfer(EVE_HalContext *phost)
267{
268 switch (phost->Host)
269 {
270 case EVE_HOST_BT8XXEMU:
271 EVE_Hal_BT8XXEMU_endTransfer(phost);
272 break;
273 case EVE_HOST_FT4222:
274 EVE_Hal_FT4222_endTransfer(phost);
275 break;
276 case EVE_HOST_MPSSE:
277 EVE_Hal_MPSSE_endTransfer(phost);
278 break;
279 default:
280 break;
281 }
282}
283
284void EVE_Hal_BT8XXEMU_flush(EVE_HalContext *phost);
285void EVE_Hal_FT4222_flush(EVE_HalContext *phost);
286void EVE_Hal_MPSSE_flush(EVE_HalContext *phost);
287EVE_HAL_EXPORT void EVE_Hal_flush(EVE_HalContext *phost)
288{
289 switch (phost->Host)
290 {
291 case EVE_HOST_BT8XXEMU:
292 EVE_Hal_BT8XXEMU_flush(phost);
293 break;
294 case EVE_HOST_FT4222:
295 EVE_Hal_FT4222_flush(phost);
296 break;
297 case EVE_HOST_MPSSE:
298 EVE_Hal_MPSSE_flush(phost);
299 break;
300 default:
301 break;
302 }
303}
304
305uint8_t EVE_Hal_BT8XXEMU_transfer8(EVE_HalContext *phost, uint8_t value);
306uint8_t EVE_Hal_FT4222_transfer8(EVE_HalContext *phost, uint8_t value);
307uint8_t EVE_Hal_MPSSE_transfer8(EVE_HalContext *phost, uint8_t value);
308EVE_HAL_EXPORT uint8_t EVE_Hal_transfer8(EVE_HalContext *phost, uint8_t value)
309{
310 switch (phost->Host)
311 {
312 case EVE_HOST_BT8XXEMU:
313 return EVE_Hal_BT8XXEMU_transfer8(phost, value);
314 case EVE_HOST_FT4222:
315 return EVE_Hal_FT4222_transfer8(phost, value);
316 case EVE_HOST_MPSSE:
317 return EVE_Hal_MPSSE_transfer8(phost, value);
318 default:
319 break;
320 }
321 return 0;
322}
323
324uint16_t EVE_Hal_BT8XXEMU_transfer16(EVE_HalContext *phost, uint16_t value);
325uint16_t EVE_Hal_FT4222_transfer16(EVE_HalContext *phost, uint16_t value);
326uint16_t EVE_Hal_MPSSE_transfer16(EVE_HalContext *phost, uint16_t value);
327EVE_HAL_EXPORT uint16_t EVE_Hal_transfer16(EVE_HalContext *phost, uint16_t value)
328{
329 switch (phost->Host)
330 {
331 case EVE_HOST_BT8XXEMU:
332 return EVE_Hal_BT8XXEMU_transfer16(phost, value);
333 case EVE_HOST_FT4222:
334 return EVE_Hal_FT4222_transfer16(phost, value);
335 case EVE_HOST_MPSSE:
336 return EVE_Hal_MPSSE_transfer16(phost, value);
337 default:
338 break;
339 }
340 return 0;
341}
342
343uint32_t EVE_Hal_BT8XXEMU_transfer32(EVE_HalContext *phost, uint32_t value);
344uint32_t EVE_Hal_FT4222_transfer32(EVE_HalContext *phost, uint32_t value);
345uint32_t EVE_Hal_MPSSE_transfer32(EVE_HalContext *phost, uint32_t value);
346EVE_HAL_EXPORT uint32_t EVE_Hal_transfer32(EVE_HalContext *phost, uint32_t value)
347{
348 switch (phost->Host)
349 {
350 case EVE_HOST_BT8XXEMU:
351 return EVE_Hal_BT8XXEMU_transfer32(phost, value);
352 case EVE_HOST_FT4222:
353 return EVE_Hal_FT4222_transfer32(phost, value);
354 case EVE_HOST_MPSSE:
355 return EVE_Hal_MPSSE_transfer32(phost, value);
356 default:
357 break;
358 }
359 return 0;
360}
361
362void EVE_Hal_BT8XXEMU_transferMem(EVE_HalContext *phost, uint8_t *result, const uint8_t *buffer, uint32_t size);
363void EVE_Hal_FT4222_transferMem(EVE_HalContext *phost, uint8_t *result, const uint8_t *buffer, uint32_t size);
364void EVE_Hal_MPSSE_transferMem(EVE_HalContext *phost, uint8_t *result, const uint8_t *buffer, uint32_t size);
365EVE_HAL_EXPORT void EVE_Hal_transferMem(EVE_HalContext *phost, uint8_t *result, const uint8_t *buffer, uint32_t size)
366{
367 switch (phost->Host)
368 {
369 case EVE_HOST_BT8XXEMU:
370 EVE_Hal_BT8XXEMU_transferMem(phost, result, buffer, size);
371 break;
372 case EVE_HOST_FT4222:
373 EVE_Hal_FT4222_transferMem(phost, result, buffer, size);
374 break;
375 case EVE_HOST_MPSSE:
376 EVE_Hal_MPSSE_transferMem(phost, result, buffer, size);
377 break;
378 default:
379 break;
380 }
381}
382
383void EVE_Hal_BT8XXEMU_transferProgMem(EVE_HalContext *phost, uint8_t *result, eve_progmem_const uint8_t *buffer, uint32_t size);
384void EVE_Hal_FT4222_transferProgMem(EVE_HalContext *phost, uint8_t *result, eve_progmem_const uint8_t *buffer, uint32_t size);
385void EVE_Hal_MPSSE_transferProgMem(EVE_HalContext *phost, uint8_t *result, eve_progmem_const uint8_t *buffer, uint32_t size);
386EVE_HAL_EXPORT void EVE_Hal_transferProgMem(EVE_HalContext *phost, uint8_t *result, eve_progmem_const uint8_t *buffer, uint32_t size)
387{
388 switch (phost->Host)
389 {
390 case EVE_HOST_BT8XXEMU:
391 EVE_Hal_BT8XXEMU_transferProgMem(phost, result, buffer, size);
392 break;
393 case EVE_HOST_FT4222:
394 EVE_Hal_FT4222_transferProgMem(phost, result, buffer, size);
395 break;
396 case EVE_HOST_MPSSE:
397 EVE_Hal_MPSSE_transferProgMem(phost, result, buffer, size);
398 break;
399 default:
400 break;
401 }
402}
403
404uint32_t EVE_Hal_BT8XXEMU_transferString(EVE_HalContext *phost, const char *str, uint32_t index, uint32_t size, uint32_t padMask);
405uint32_t EVE_Hal_FT4222_transferString(EVE_HalContext *phost, const char *str, uint32_t index, uint32_t size, uint32_t padMask);
406uint32_t EVE_Hal_MPSSE_transferString(EVE_HalContext *phost, const char *str, uint32_t index, uint32_t size, uint32_t padMask);
407EVE_HAL_EXPORT uint32_t EVE_Hal_transferString(EVE_HalContext *phost, const char *str, uint32_t index, uint32_t size, uint32_t padMask)
408{
409 switch (phost->Host)
410 {
411 case EVE_HOST_BT8XXEMU:
412 return EVE_Hal_BT8XXEMU_transferString(phost, str, index, size, padMask);
413 case EVE_HOST_FT4222:
414 return EVE_Hal_FT4222_transferString(phost, str, index, size, padMask);
415 case EVE_HOST_MPSSE:
416 return EVE_Hal_MPSSE_transferString(phost, str, index, size, padMask);
417 default:
418 break;
419 }
420 return 0;
421}
423
424/************
425** UTILITY **
426************/
427
430
431void EVE_Hal_BT8XXEMU_hostCommand(EVE_HalContext *phost, uint8_t cmd);
432void EVE_Hal_FT4222_hostCommand(EVE_HalContext *phost, uint8_t cmd);
433void EVE_Hal_MPSSE_hostCommand(EVE_HalContext *phost, uint8_t cmd);
434EVE_HAL_EXPORT void EVE_Hal_hostCommand(EVE_HalContext *phost, uint8_t cmd)
435{
436 switch (phost->Host)
437 {
438 case EVE_HOST_BT8XXEMU:
439 EVE_Hal_BT8XXEMU_hostCommand(phost, cmd);
440 break;
441 case EVE_HOST_FT4222:
442 EVE_Hal_FT4222_hostCommand(phost, cmd);
443 break;
444 case EVE_HOST_MPSSE:
445 EVE_Hal_MPSSE_hostCommand(phost, cmd);
446 break;
447 default:
448 break;
449 }
450}
451
452/* This API sends a 3byte command to the phost */
453void EVE_Hal_BT8XXEMU_hostCommandExt3(EVE_HalContext *phost, uint8_t cmd);
454void EVE_Hal_FT4222_hostCommandExt3(EVE_HalContext *phost, uint8_t cmd);
455void EVE_Hal_MPSSE_hostCommandExt3(EVE_HalContext *phost, uint8_t cmd);
456EVE_HAL_EXPORT void EVE_Hal_hostCommandExt3(EVE_HalContext *phost, uint32_t cmd)
457{
458 switch (phost->Host)
459 {
460 case EVE_HOST_BT8XXEMU:
461 EVE_Hal_BT8XXEMU_hostCommandExt3(phost, cmd);
462 break;
463 case EVE_HOST_FT4222:
464 EVE_Hal_FT4222_hostCommandExt3(phost, cmd);
465 break;
466 case EVE_HOST_MPSSE:
467 EVE_Hal_MPSSE_hostCommandExt3(phost, cmd);
468 break;
469 default:
470 break;
471 }
472}
473
474/* Toggle PD_N pin of FT800 board for a power cycle */
475bool EVE_Hal_BT8XXEMU_powerCycle(EVE_HalContext *phost, bool up);
476bool EVE_Hal_FT4222_powerCycle(EVE_HalContext *phost, bool up);
477bool EVE_Hal_MPSSE_powerCycle(EVE_HalContext *phost, bool up);
478EVE_HAL_EXPORT bool EVE_Hal_powerCycle(EVE_HalContext *phost, bool up)
479{
480 switch (phost->Host)
481 {
482 case EVE_HOST_BT8XXEMU:
483 return EVE_Hal_BT8XXEMU_powerCycle(phost, up);
484 break;
485 case EVE_HOST_FT4222:
486 return EVE_Hal_FT4222_powerCycle(phost, up);
487 break;
488 case EVE_HOST_MPSSE:
489 return EVE_Hal_MPSSE_powerCycle(phost, up);
490 break;
491 default:
492 break;
493 }
494 return false;
495}
496
497void EVE_Hal_BT8XXEMU_setSPI(EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy);
498void EVE_Hal_FT4222_setSPI(EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy);
499void EVE_Hal_MPSSE_setSPI(EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy);
500EVE_HAL_EXPORT void EVE_Hal_setSPI(EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy)
501{
502 switch (phost->Host)
503 {
504 case EVE_HOST_BT8XXEMU:
505 EVE_Hal_BT8XXEMU_setSPI(phost, numchnls, numdummy);
506 break;
507 case EVE_HOST_FT4222:
508 EVE_Hal_FT4222_setSPI(phost, numchnls, numdummy);
509 break;
510 case EVE_HOST_MPSSE:
511 EVE_Hal_MPSSE_setSPI(phost, numchnls, numdummy);
512 break;
513 default:
514 break;
515 }
516}
517
518void EVE_Hal_BT8XXEMU_restoreSPI(EVE_HalContext *phost);
519void EVE_Hal_FT4222_restoreSPI(EVE_HalContext *phost);
520void EVE_Hal_MPSSE_restoreSPI(EVE_HalContext *phost);
521EVE_HAL_EXPORT void EVE_Hal_restoreSPI(EVE_HalContext *phost)
522{
523 switch (phost->Host)
524 {
525 case EVE_HOST_BT8XXEMU:
526 EVE_Hal_BT8XXEMU_restoreSPI(phost);
527 break;
528 case EVE_HOST_FT4222:
529 EVE_Hal_FT4222_restoreSPI(phost);
530 break;
531 case EVE_HOST_MPSSE:
532 EVE_Hal_MPSSE_restoreSPI(phost);
533 break;
534 default:
535 break;
536 }
537}
539
540/*********
541** MISC **
542*********/
543
546
547bool EVE_UtilImpl_BT8XXEMU_bootupDisplayGpio(EVE_HalContext *phost);
548bool EVE_UtilImpl_FT4222_bootupDisplayGpio(EVE_HalContext *phost);
549bool EVE_UtilImpl_MPSSE_bootupDisplayGpio(EVE_HalContext *phost);
550bool EVE_UtilImpl_bootupDisplayGpio(EVE_HalContext *phost)
551{
552 switch (phost->Host)
553 {
554 case EVE_HOST_BT8XXEMU:
555 return EVE_UtilImpl_BT8XXEMU_bootupDisplayGpio(phost);
556 case EVE_HOST_FT4222:
557 return EVE_UtilImpl_FT4222_bootupDisplayGpio(phost);
558 case EVE_HOST_MPSSE:
559 return EVE_UtilImpl_MPSSE_bootupDisplayGpio(phost);
560 default:
561 break;
562 }
563 return false;
564}
566
567#endif /* #if defined(BT8XXEMU_PLATFORM) */
568
569/* end of file */
EVE_HAL_EXPORT
#define EVE_HAL_EXPORT
Definition EVE_Config.h:1410
eve_progmem_const
#define eve_progmem_const
Definition EVE_Config.h:1499
EVE_SPI_CHANNELS_T
EVE_SPI_CHANNELS_T
Definition EVE_GpuTypes.h:45
EVE_Hal_powerCycle
EVE_HAL_EXPORT bool EVE_Hal_powerCycle(EVE_HalContext *phost, bool up)
Toggle PD_N pin of FT800 board for a power cycle.
Definition EVE_HalImpl_FT9XX.c:588
EVE_Hal_transfer8
EVE_HAL_EXPORT uint8_t EVE_Hal_transfer8(EVE_HalContext *phost, uint8_t value)
Write 8 bits to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:362
EVE_Hal_transfer16
EVE_HAL_EXPORT uint16_t EVE_Hal_transfer16(EVE_HalContext *phost, uint16_t value)
Write 2 bytes to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:374
EVE_Hal_isDevice
EVE_HAL_EXPORT bool EVE_Hal_isDevice(EVE_HalContext *phost, size_t deviceIdx)
Check whether the context is the specified device.
Definition EVE_HalImpl_FT9XX.c:103
EVE_Hal_info
EVE_HAL_EXPORT void EVE_Hal_info(EVE_DeviceInfo *deviceInfo, size_t deviceIdx)
Get info of the specified device. Devices of type EVE_HOST_UNKNOWN should be ignored.
Definition EVE_HalImpl_FT9XX.c:87
EVE_Hal_startTransfer
EVE_HAL_EXPORT void EVE_Hal_startTransfer(EVE_HalContext *phost, EVE_TRANSFER_T rw, uint32_t addr)
Start data transfer to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:257
EVE_Hal_hostCommand
EVE_HAL_EXPORT void EVE_Hal_hostCommand(EVE_HalContext *phost, uint8_t cmd)
Send a host command to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:544
EVE_TRANSFER_T
EVE_TRANSFER_T
Definition EVE_HalDefs.h:65
EVE_Hal_setSPI
EVE_HAL_EXPORT void EVE_Hal_setSPI(EVE_HalContext *phost, EVE_SPI_CHANNELS_T numchnls, uint8_t numdummy)
Set number of SPI channel.
Definition EVE_HalImpl_FT9XX.c:615
EVE_Hal_transferString
EVE_HAL_EXPORT uint32_t EVE_Hal_transferString(EVE_HalContext *phost, const char *str, uint32_t index, uint32_t size, uint32_t padMask)
Transfer a string to EVE platform.
Definition EVE_HalImpl_FT9XX.c:496
EVE_HOST_FT4222
@ EVE_HOST_FT4222
Definition EVE_HalDefs.h:135
EVE_HOST_MPSSE
@ EVE_HOST_MPSSE
Definition EVE_HalDefs.h:136
EVE_HOST_BT8XXEMU
@ EVE_HOST_BT8XXEMU
Definition EVE_HalDefs.h:134
EVE_Hal_list
EVE_HAL_EXPORT size_t EVE_Hal_list()
List the available devices.
Definition EVE_HalImpl_FT9XX.c:76
EVE_Hal_transferMem
EVE_HAL_EXPORT void EVE_Hal_transferMem(EVE_HalContext *phost, uint8_t *result, const uint8_t *buffer, uint32_t size)
Transfer (read/write) a block data to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:429
EVE_Hal_transferProgMem
EVE_HAL_EXPORT void EVE_Hal_transferProgMem(EVE_HalContext *phost, uint8_t *result, eve_progmem_const uint8_t *buffer, uint32_t size)
Transfer a block data from program memory.
Definition EVE_HalImpl_FT9XX.c:457
EVE_Hal_restoreSPI
EVE_HAL_EXPORT void EVE_Hal_restoreSPI(EVE_HalContext *phost)
Definition EVE_HalImpl_FT9XX.c:636
EVE_Hal_endTransfer
EVE_HAL_EXPORT void EVE_Hal_endTransfer(EVE_HalContext *phost)
End data transfer.
Definition EVE_HalImpl_FT9XX.c:291
EVE_Hal_flush
EVE_HAL_EXPORT void EVE_Hal_flush(EVE_HalContext *phost)
Flush data to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:304
EVE_Hal_hostCommandExt3
EVE_HAL_EXPORT void EVE_Hal_hostCommandExt3(EVE_HalContext *phost, uint32_t cmd)
This API sends a 3byte command to the phost.
Definition EVE_HalImpl_FT9XX.c:565
EVE_Hal_transfer32
EVE_HAL_EXPORT uint32_t EVE_Hal_transfer32(EVE_HalContext *phost, uint32_t value)
Write 4 bytes to Coprocessor.
Definition EVE_HalImpl_FT9XX.c:399
EVE_HalImpl.h
Eve_Hal framework APIs.
EVE_HalImpl_open
bool EVE_HalImpl_open(EVE_HalContext *phost, const EVE_HalParameters *parameters)
Opens a new HAL context using the specified parameters.
Definition EVE_HalImpl_FT9XX.c:191
EVE_HalImpl_defaults
bool EVE_HalImpl_defaults(EVE_HalParameters *parameters, size_t deviceIdx)
Get the default configuration parameters.
Definition EVE_HalImpl_FT9XX.c:116
EVE_HalImpl_close
void EVE_HalImpl_close(EVE_HalContext *phost)
Close a HAL context.
Definition EVE_HalImpl_FT9XX.c:223
EVE_HalImpl_initialize
void EVE_HalImpl_initialize()
Initialize HAL platform.
Definition EVE_HalImpl_FT9XX.c:57
EVE_UtilImpl_bootupDisplayGpio
bool EVE_UtilImpl_bootupDisplayGpio(EVE_HalContext *phost)
Display GPIO pins.
Definition EVE_HalImpl_FT9XX.c:915
EVE_HalImpl_idle
void EVE_HalImpl_idle(EVE_HalContext *phost)
Idle. Call regularly to update frequently changing internal state.
Definition EVE_HalImpl_FT9XX.c:237
EVE_HalImpl_release
void EVE_HalImpl_release()
Release HAL platform.
Definition EVE_HalImpl_FT9XX.c:65
uint16_t
unsigned short uint16_t
Definition EVE_IntTypes_MSVC12.h:41
uint32_t
unsigned int uint32_t
Definition EVE_IntTypes_MSVC12.h:42
uint8_t
unsigned char uint8_t
Definition EVE_IntTypes_MSVC12.h:40
EVE_Platform.h
Platform selector.
buffer
static ft_uint32_t ft_uint8_t * buffer
Definition FT_Gpu_Hal.h:139
cmd
static ft_void_t ft_uint32_t * cmd
Definition FT_Gpu_Hal.h:184
addr
static ft_uint32_t addr
Definition FT_Gpu_Hal.h:139
DWORD
unsigned long DWORD
Definition ff.h:61
EVE_DeviceInfo
Definition EVE_HalDefs.h:143
EVE_HalContext
Definition EVE_HalDefs.h:233
EVE_HalParameters
Definition EVE_HalDefs.h:153