1extern crate libc;
2use libc::{c_char, c_void, size_t};
3
4#[cfg_attr(feature = "static", link(name = "NiFpga", kind = "static"))]
5#[cfg_attr(not(feature = "static"), link(name = "NiFpga"))]
6extern "C" {
7 #[link_name = "NiFpga_Initialize"]
8 pub fn initialize() -> i32;
9
10 #[link_name = "NiFpga_Open"]
11 pub fn open(
12 bitfile: *const c_char,
13 signature: *const c_char,
14 resource: *const c_char,
15 attribute: u32,
16 session: *mut u32,
17 ) -> i32;
18
19 #[link_name = "NiFpga_Close"]
20 pub fn close(session: u32, attribute: u32) -> i32;
21
22 #[link_name = "NiFpga_Finalize"]
23 pub fn finalize() -> i32;
24
25 #[link_name = "NiFpga_Run"]
26 pub fn run(session: u32) -> i32;
27
28 #[link_name = "NiFpga_Abort"]
29 pub fn abort(session: u32) -> i32;
30
31 #[link_name = "NiFpga_Reset"]
32 pub fn reset(session: u32) -> i32;
33
34 #[link_name = "NiFpga_Download"]
35 pub fn download(session: u32) -> i32;
36
37 #[link_name = "NiFpga_ReadI8"]
38 pub fn read_i8(session: u32, indicator: u32, value: *mut i8) -> i32;
39
40 #[link_name = "NiFpga_WriteI8"]
41 pub fn write_i8(session: u32, control: u32, value: i8) -> i32;
42
43 #[link_name = "NiFpga_ReadArrayI8"]
44 pub fn read_array_i8(session: u32, indicator: u32, array: *mut i8, size: size_t) -> i32;
45
46 #[link_name = "NiFpga_WriteArrayI8"]
47 pub fn write_array_i8(session: u32, indicator: u32, array: *const i8, size: size_t) -> i32;
48
49 #[link_name = "NiFpga_ReadU8"]
50 pub fn read_u8(session: u32, indicator: u32, value: *mut u8) -> i32;
51
52 #[link_name = "NiFpga_WriteU8"]
53 pub fn write_u8(session: u32, control: u32, value: u8) -> i32;
54
55 #[link_name = "NiFpga_ReadArrayU8"]
56 pub fn read_array_u8(session: u32, indicator: u32, array: *mut u8, size: size_t) -> i32;
57
58 #[link_name = "NiFpga_WriteArrayU8"]
59 pub fn write_array_u8(session: u32, indicator: u32, array: *const u8, size: size_t) -> i32;
60
61 #[link_name = "NiFpga_ReadI16"]
62 pub fn read_i16(session: u32, indicator: u32, value: *mut i16) -> i32;
63
64 #[link_name = "NiFpga_WriteI16"]
65 pub fn write_i16(session: u32, control: u32, value: i16) -> i32;
66
67 #[link_name = "NiFpga_ReadArrayI16"]
68 pub fn read_array_i16(session: u32, indicator: u32, array: *mut i16, size: size_t) -> i32;
69
70 #[link_name = "NiFpga_WriteArrayI16"]
71 pub fn write_array_i16(session: u32, indicator: u32, array: *const i16, size: size_t) -> i32;
72
73 #[link_name = "NiFpga_ReadU16"]
74 pub fn read_u16(session: u32, indicator: u32, value: *mut u16) -> i32;
75
76 #[link_name = "NiFpga_WriteU16"]
77 pub fn write_u16(session: u32, control: u32, value: u16) -> i32;
78
79 #[link_name = "NiFpga_ReadArrayU16"]
80 pub fn read_array_u16(session: u32, indicator: u32, array: *mut u16, size: size_t) -> i32;
81
82 #[link_name = "NiFpga_WriteArrayU16"]
83 pub fn write_array_u16(session: u32, indicator: u32, array: *const u16, size: size_t) -> i32;
84
85 #[link_name = "NiFpga_ReadI32"]
86 pub fn read_i32(session: u32, indicator: u32, value: *mut i32) -> i32;
87
88 #[link_name = "NiFpga_WriteI32"]
89 pub fn write_i32(session: u32, control: u32, value: i32) -> i32;
90
91 #[link_name = "NiFpga_ReadArrayI32"]
92 pub fn read_array_i32(session: u32, indicator: u32, array: *mut i32, size: size_t) -> i32;
93
94 #[link_name = "NiFpga_WriteArrayI32"]
95 pub fn write_array_i32(session: u32, indicator: u32, array: *const i32, size: size_t) -> i32;
96
97 #[link_name = "NiFpga_ReadU32"]
98 pub fn read_u32(session: u32, indicator: u32, value: *mut u32) -> i32;
99
100 #[link_name = "NiFpga_WriteU32"]
101 pub fn write_u32(session: u32, control: u32, value: u32) -> i32;
102
103 #[link_name = "NiFpga_ReadArrayU32"]
104 pub fn read_array_u32(session: u32, indicator: u32, array: *mut u32, size: size_t) -> i32;
105
106 #[link_name = "NiFpga_WriteArrayU32"]
107 pub fn write_array_u32(session: u32, indicator: u32, array: *const u32, size: size_t) -> i32;
108
109 #[link_name = "NiFpga_ReadI64"]
110 pub fn read_i64(session: u32, indicator: u32, value: *mut i64) -> i32;
111
112 #[link_name = "NiFpga_WriteI64"]
113 pub fn write_i64(session: u32, control: u32, value: i64) -> i32;
114
115 #[link_name = "NiFpga_ReadArrayI64"]
116 pub fn read_array_i64(session: u32, indicator: u32, array: *mut i64, size: size_t) -> i32;
117
118 #[link_name = "NiFpga_WriteArrayI64"]
119 pub fn write_array_i64(session: u32, indicator: u32, array: *const i64, size: size_t) -> i32;
120
121 #[link_name = "NiFpga_ReadU64"]
122 pub fn read_u64(session: u32, indicator: u32, value: *mut u64) -> i32;
123
124 #[link_name = "NiFpga_WriteU64"]
125 pub fn write_u64(session: u32, control: u32, value: u64) -> i32;
126
127 #[link_name = "NiFpga_ReadArrayU64"]
128 pub fn read_array_u64(session: u32, indicator: u32, array: *mut u64, size: size_t) -> i32;
129
130 #[link_name = "NiFpga_WriteArrayU64"]
131 pub fn write_array_u64(session: u32, indicator: u32, array: *const u64, size: size_t) -> i32;
132
133 #[link_name = "NiFpga_ReadSgl"]
134 pub fn read_f32(session: u32, indicator: u32, value: *mut f32) -> i32;
135
136 #[link_name = "NiFpga_WriteSgl"]
137 pub fn write_f32(session: u32, control: u32, value: f32) -> i32;
138
139 #[link_name = "NiFpga_ReadArraySgl"]
140 pub fn read_array_f32(session: u32, indicator: u32, array: *mut f32, size: size_t) -> i32;
141
142 #[link_name = "NiFpga_WriteArraySgl"]
143 pub fn write_array_f32(session: u32, indicator: u32, array: *const f32, size: size_t) -> i32;
144
145 #[link_name = "NiFpga_ReadDbl"]
146 pub fn read_f64(session: u32, indicator: u32, value: *mut f64) -> i32;
147
148 #[link_name = "NiFpga_WriteDbl"]
149 pub fn write_f64(session: u32, control: u32, value: f64) -> i32;
150
151 #[link_name = "NiFpga_ReadArrayDbl"]
152 pub fn read_array_f64(session: u32, indicator: u32, array: *mut f64, size: size_t) -> i32;
153
154 #[link_name = "NiFpga_WriteArrayDbl"]
155 pub fn write_array_f64(session: u32, indicator: u32, array: *const f64, size: size_t) -> i32;
156
157 #[link_name = "NiFpga_ReadBool"]
158 pub fn read_bool(session: u32, indicator: u32, value: *mut bool) -> i32;
159
160 #[link_name = "NiFpga_WriteBool"]
161 pub fn write_bool(session: u32, control: u32, value: bool) -> i32;
162
163 #[link_name = "NiFpga_ReadArrayBool"]
164 pub fn read_array_bool(session: u32, indicator: u32, array: *mut bool, size: size_t) -> i32;
165
166 #[link_name = "NiFpga_WriteArrayBool"]
167 pub fn write_array_bool(session: u32, indicator: u32, array: *const bool, size: size_t) -> i32;
168
169 #[link_name = "NiFpga_ReserveIrqContext"]
170 pub fn reserve_irq_context(session: u32, context: *mut *const c_void) -> i32;
171
172 #[link_name = "NiFpga_UnreserveIrqContext"]
173 pub fn unreserve_irq_context(session: u32, context: *const c_void) -> i32;
174
175 #[link_name = "NiFpga_WaitOnIrqs"]
176 pub fn wait_on_irqs(
177 session: u32,
178 context: *const c_void,
179 irqs: u32,
180 timeout: u32,
181 irqsAsserted: *mut u32,
182 timedOut: *mut u8,
183 ) -> i32;
184
185 #[link_name = "NiFpga_AcknowledgeIrqs"]
186 pub fn acknowledge_irqs(session: u32, irqs: u32) -> i32;
187
188 #[link_name = "NiFpga_ConfigureFifo"]
189 pub fn configure_fifo(session: u32, fifo: u32, depth: size_t) -> i32;
190
191 #[link_name = "NiFpga_ConfigureFifo2"]
192 pub fn configure_fifo2(
193 session: u32,
194 fifo: u32,
195 requestedDepth: size_t,
196 actualDepth: *mut size_t,
197 ) -> i32;
198
199 #[link_name = "NiFpga_StartFifo"]
200 pub fn start_fifo(session: u32, fifo: u32) -> i32;
201
202 #[link_name = "NiFpga_StopFifo"]
203 pub fn stop_fifo(session: u32, fifo: u32) -> i32;
204
205 #[link_name = "NiFpga_ReadFifoI8"]
206 pub fn read_fifo_i8(
207 session: u32,
208 fifo: u32,
209 data: *mut i8,
210 numberOfElements: size_t,
211 timeout: u32,
212 elementsRemaining: *mut size_t,
213 ) -> i32;
214
215 #[link_name = "NiFpga_WriteFifoI8"]
216 pub fn write_fifo_i8(
217 session: u32,
218 fifo: u32,
219 data: *const i8,
220 numberOfElements: size_t,
221 timeout: u32,
222 emptyElementsRemaining: *mut size_t,
223 ) -> i32;
224
225 #[link_name = "NiFpga_AcquireFifoReadElementsI8"]
226 pub fn acquire_fifo_read_elements_i8(
227 session: u32,
228 fifo: u32,
229 elements: *mut *const i8,
230 elementsRequested: size_t,
231 timeout: u32,
232 elementsAcquired: *mut size_t,
233 elementsRemaining: *mut size_t,
234 ) -> i32;
235
236 #[link_name = "NiFpga_AcquireFifoWriteElementsI8"]
237 pub fn acquire_fifo_write_elements_i8(
238 session: u32,
239 fifo: u32,
240 elements: *mut *mut i8,
241 elementsRequested: size_t,
242 timeout: u32,
243 elementsAcquired: *mut size_t,
244 elementsRemaining: *mut size_t,
245 ) -> i32;
246
247 #[link_name = "NiFpga_ReadFifoU8"]
248 pub fn read_fifo_u8(
249 session: u32,
250 fifo: u32,
251 data: *mut u8,
252 numberOfElements: size_t,
253 timeout: u32,
254 elementsRemaining: *mut size_t,
255 ) -> i32;
256
257 #[link_name = "NiFpga_WriteFifoU8"]
258 pub fn write_fifo_u8(
259 session: u32,
260 fifo: u32,
261 data: *const u8,
262 numberOfElements: size_t,
263 timeout: u32,
264 emptyElementsRemaining: *mut size_t,
265 ) -> i32;
266
267 #[link_name = "NiFpga_AcquireFifoReadElementsU8"]
268 pub fn acquire_fifo_read_elements_u8(
269 session: u32,
270 fifo: u32,
271 elements: *mut *const u8,
272 elementsRequested: size_t,
273 timeout: u32,
274 elementsAcquired: *mut size_t,
275 elementsRemaining: *mut size_t,
276 ) -> i32;
277
278 #[link_name = "NiFpga_AcquireFifoWriteElementsU8"]
279 pub fn acquire_fifo_write_elements_u8(
280 session: u32,
281 fifo: u32,
282 elements: *mut *mut u8,
283 elementsRequested: size_t,
284 timeout: u32,
285 elementsAcquired: *mut size_t,
286 elementsRemaining: *mut size_t,
287 ) -> i32;
288
289 #[link_name = "NiFpga_ReadFifoI16"]
290 pub fn read_fifo_i16(
291 session: u32,
292 fifo: u32,
293 data: *mut i16,
294 numberOfElements: size_t,
295 timeout: u32,
296 elementsRemaining: *mut size_t,
297 ) -> i32;
298
299 #[link_name = "NiFpga_WriteFifoI16"]
300 pub fn write_fifo_i16(
301 session: u32,
302 fifo: u32,
303 data: *const i16,
304 numberOfElements: size_t,
305 timeout: u32,
306 emptyElementsRemaining: *mut size_t,
307 ) -> i32;
308
309 #[link_name = "NiFpga_AcquireFifoReadElementsI16"]
310 pub fn acquire_fifo_read_elements_i16(
311 session: u32,
312 fifo: u32,
313 elements: *mut *const i16,
314 elementsRequested: size_t,
315 timeout: u32,
316 elementsAcquired: *mut size_t,
317 elementsRemaining: *mut size_t,
318 ) -> i32;
319
320 #[link_name = "NiFpga_AcquireFifoWriteElementsI16"]
321 pub fn acquire_fifo_write_elements_i16(
322 session: u32,
323 fifo: u32,
324 elements: *mut *mut i16,
325 elementsRequested: size_t,
326 timeout: u32,
327 elementsAcquired: *mut size_t,
328 elementsRemaining: *mut size_t,
329 ) -> i32;
330
331 #[link_name = "NiFpga_ReadFifoU16"]
332 pub fn read_fifo_u16(
333 session: u32,
334 fifo: u32,
335 data: *mut u16,
336 numberOfElements: size_t,
337 timeout: u32,
338 elementsRemaining: *mut size_t,
339 ) -> i32;
340
341 #[link_name = "NiFpga_WriteFifoU16"]
342 pub fn write_fifo_u16(
343 session: u32,
344 fifo: u32,
345 data: *const u16,
346 numberOfElements: size_t,
347 timeout: u32,
348 emptyElementsRemaining: *mut size_t,
349 ) -> i32;
350
351 #[link_name = "NiFpga_AcquireFifoReadElementsU16"]
352 pub fn acquire_fifo_read_elements_u16(
353 session: u32,
354 fifo: u32,
355 elements: *mut *const u16,
356 elementsRequested: size_t,
357 timeout: u32,
358 elementsAcquired: *mut size_t,
359 elementsRemaining: *mut size_t,
360 ) -> i32;
361
362 #[link_name = "NiFpga_AcquireFifoWriteElementsU16"]
363 pub fn acquire_fifo_write_elements_u16(
364 session: u32,
365 fifo: u32,
366 elements: *mut *mut u16,
367 elementsRequested: size_t,
368 timeout: u32,
369 elementsAcquired: *mut size_t,
370 elementsRemaining: *mut size_t,
371 ) -> i32;
372
373 #[link_name = "NiFpga_ReadFifoI32"]
374 pub fn read_fifo_i32(
375 session: u32,
376 fifo: u32,
377 data: *mut i32,
378 numberOfElements: size_t,
379 timeout: u32,
380 elementsRemaining: *mut size_t,
381 ) -> i32;
382
383 #[link_name = "NiFpga_WriteFifoI32"]
384 pub fn write_fifo_i32(
385 session: u32,
386 fifo: u32,
387 data: *const i32,
388 numberOfElements: size_t,
389 timeout: u32,
390 emptyElementsRemaining: *mut size_t,
391 ) -> i32;
392
393 #[link_name = "NiFpga_AcquireFifoReadElementsI32"]
394 pub fn acquire_fifo_read_elements_i32(
395 session: u32,
396 fifo: u32,
397 elements: *mut *const i32,
398 elementsRequested: size_t,
399 timeout: u32,
400 elementsAcquired: *mut size_t,
401 elementsRemaining: *mut size_t,
402 ) -> i32;
403
404 #[link_name = "NiFpga_AcquireFifoWriteElementsI32"]
405 pub fn acquire_fifo_write_elements_i32(
406 session: u32,
407 fifo: u32,
408 elements: *mut *mut i32,
409 elementsRequested: size_t,
410 timeout: u32,
411 elementsAcquired: *mut size_t,
412 elementsRemaining: *mut size_t,
413 ) -> i32;
414
415 #[link_name = "NiFpga_ReadFifoU32"]
416 pub fn read_fifo_u32(
417 session: u32,
418 fifo: u32,
419 data: *mut u32,
420 numberOfElements: size_t,
421 timeout: u32,
422 elementsRemaining: *mut size_t,
423 ) -> i32;
424
425 #[link_name = "NiFpga_WriteFifoU32"]
426 pub fn write_fifo_u32(
427 session: u32,
428 fifo: u32,
429 data: *const u32,
430 numberOfElements: size_t,
431 timeout: u32,
432 emptyElementsRemaining: *mut size_t,
433 ) -> i32;
434
435 #[link_name = "NiFpga_AcquireFifoReadElementsU32"]
436 pub fn acquire_fifo_read_elements_u32(
437 session: u32,
438 fifo: u32,
439 elements: *mut *const u32,
440 elementsRequested: size_t,
441 timeout: u32,
442 elementsAcquired: *mut size_t,
443 elementsRemaining: *mut size_t,
444 ) -> i32;
445
446 #[link_name = "NiFpga_AcquireFifoWriteElementsU32"]
447 pub fn acquire_fifo_write_elements_u32(
448 session: u32,
449 fifo: u32,
450 elements: *mut *mut u32,
451 elementsRequested: size_t,
452 timeout: u32,
453 elementsAcquired: *mut size_t,
454 elementsRemaining: *mut size_t,
455 ) -> i32;
456
457 #[link_name = "NiFpga_ReadFifoI64"]
458 pub fn read_fifo_i64(
459 session: u32,
460 fifo: u32,
461 data: *mut i64,
462 numberOfElements: size_t,
463 timeout: u32,
464 elementsRemaining: *mut size_t,
465 ) -> i32;
466
467 #[link_name = "NiFpga_WriteFifoI64"]
468 pub fn write_fifo_i64(
469 session: u32,
470 fifo: u32,
471 data: *const i64,
472 numberOfElements: size_t,
473 timeout: u32,
474 emptyElementsRemaining: *mut size_t,
475 ) -> i32;
476
477 #[link_name = "NiFpga_AcquireFifoReadElementsI64"]
478 pub fn acquire_fifo_read_elements_i64(
479 session: u32,
480 fifo: u32,
481 elements: *mut *const i64,
482 elementsRequested: size_t,
483 timeout: u32,
484 elementsAcquired: *mut size_t,
485 elementsRemaining: *mut size_t,
486 ) -> i32;
487
488 #[link_name = "NiFpga_AcquireFifoWriteElementsI64"]
489 pub fn acquire_fifo_write_elements_i64(
490 session: u32,
491 fifo: u32,
492 elements: *mut *mut i64,
493 elementsRequested: size_t,
494 timeout: u32,
495 elementsAcquired: *mut size_t,
496 elementsRemaining: *mut size_t,
497 ) -> i32;
498
499 #[link_name = "NiFpga_ReadFifoU64"]
500 pub fn read_fifo_u64(
501 session: u32,
502 fifo: u32,
503 data: *mut u64,
504 numberOfElements: size_t,
505 timeout: u32,
506 elementsRemaining: *mut size_t,
507 ) -> i32;
508
509 #[link_name = "NiFpga_WriteFifoU64"]
510 pub fn write_fifo_u64(
511 session: u32,
512 fifo: u32,
513 data: *const u64,
514 numberOfElements: size_t,
515 timeout: u32,
516 emptyElementsRemaining: *mut size_t,
517 ) -> i32;
518
519 #[link_name = "NiFpga_AcquireFifoReadElementsU64"]
520 pub fn acquire_fifo_read_elements_u64(
521 session: u32,
522 fifo: u32,
523 elements: *mut *const u64,
524 elementsRequested: size_t,
525 timeout: u32,
526 elementsAcquired: *mut size_t,
527 elementsRemaining: *mut size_t,
528 ) -> i32;
529
530 #[link_name = "NiFpga_AcquireFifoWriteElementsU64"]
531 pub fn acquire_fifo_write_elements_u64(
532 session: u32,
533 fifo: u32,
534 elements: *mut *mut u64,
535 elementsRequested: size_t,
536 timeout: u32,
537 elementsAcquired: *mut size_t,
538 elementsRemaining: *mut size_t,
539 ) -> i32;
540
541 #[link_name = "NiFpga_ReadFifoSgl"]
542 pub fn read_fifo_f32(
543 session: u32,
544 fifo: u32,
545 data: *mut f32,
546 numberOfElements: size_t,
547 timeout: u32,
548 elementsRemaining: *mut size_t,
549 ) -> i32;
550
551 #[link_name = "NiFpga_WriteFifoSgl"]
552 pub fn write_fifo_f32(
553 session: u32,
554 fifo: u32,
555 data: *const f32,
556 numberOfElements: size_t,
557 timeout: u32,
558 emptyElementsRemaining: *mut size_t,
559 ) -> i32;
560
561 #[link_name = "NiFpga_AcquireFifoReadElementsSgl"]
562 pub fn acquire_fifo_read_elements_f32(
563 session: u32,
564 fifo: u32,
565 elements: *mut *const f32,
566 elementsRequested: size_t,
567 timeout: u32,
568 elementsAcquired: *mut size_t,
569 elementsRemaining: *mut size_t,
570 ) -> i32;
571
572 #[link_name = "NiFpga_AcquireFifoWriteElementsSgl"]
573 pub fn acquire_fifo_write_elements_f32(
574 session: u32,
575 fifo: u32,
576 elements: *mut *mut f32,
577 elementsRequested: size_t,
578 timeout: u32,
579 elementsAcquired: *mut size_t,
580 elementsRemaining: *mut size_t,
581 ) -> i32;
582
583 #[link_name = "NiFpga_ReadFifoDbl"]
584 pub fn read_fifo_f64(
585 session: u32,
586 fifo: u32,
587 data: *mut f64,
588 numberOfElements: size_t,
589 timeout: u32,
590 elementsRemaining: *mut size_t,
591 ) -> i32;
592
593 #[link_name = "NiFpga_WriteFifoDbl"]
594 pub fn write_fifo_f64(
595 session: u32,
596 fifo: u32,
597 data: *const f64,
598 numberOfElements: size_t,
599 timeout: u32,
600 emptyElementsRemaining: *mut size_t,
601 ) -> i32;
602
603 #[link_name = "NiFpga_AcquireFifoReadElementsDbl"]
604 pub fn acquire_fifo_read_elements_f64(
605 session: u32,
606 fifo: u32,
607 elements: *mut *const f64,
608 elementsRequested: size_t,
609 timeout: u32,
610 elementsAcquired: *mut size_t,
611 elementsRemaining: *mut size_t,
612 ) -> i32;
613
614 #[link_name = "NiFpga_AcquireFifoWriteElementsDbl"]
615 pub fn acquire_fifo_write_elements_f64(
616 session: u32,
617 fifo: u32,
618 elements: *mut *mut f64,
619 elementsRequested: size_t,
620 timeout: u32,
621 elementsAcquired: *mut size_t,
622 elementsRemaining: *mut size_t,
623 ) -> i32;
624
625 #[link_name = "NiFpga_ReadFifoBool"]
626 pub fn read_fifo_bool(
627 session: u32,
628 fifo: u32,
629 data: *mut bool,
630 numberOfElements: size_t,
631 timeout: u32,
632 elementsRemaining: *mut size_t,
633 ) -> i32;
634
635 #[link_name = "NiFpga_WriteFifoBool"]
636 pub fn write_fifo_bool(
637 session: u32,
638 fifo: u32,
639 data: *const bool,
640 numberOfElements: size_t,
641 timeout: u32,
642 emptyElementsRemaining: *mut size_t,
643 ) -> i32;
644
645 #[link_name = "NiFpga_AcquireFifoReadElementsBool"]
646 pub fn acquire_fifo_read_elements_bool(
647 session: u32,
648 fifo: u32,
649 elements: *mut *const bool,
650 elementsRequested: size_t,
651 timeout: u32,
652 elementsAcquired: *mut size_t,
653 elementsRemaining: *mut size_t,
654 ) -> i32;
655
656 #[link_name = "NiFpga_AcquireFifoWriteElementsBool"]
657 pub fn acquire_fifo_write_elements_bool(
658 session: u32,
659 fifo: u32,
660 elements: *mut *mut bool,
661 elementsRequested: size_t,
662 timeout: u32,
663 elementsAcquired: *mut size_t,
664 elementsRemaining: *mut size_t,
665 ) -> i32;
666
667 #[link_name = "NiFpga_ReleaseFifoElements"]
668 pub fn release_fifo_elements(session: u32, fifo: u32, elements: size_t) -> i32;
669
670 #[link_name = "NiFpga_GetPeerToPeerFifoEndpoint"]
671 pub fn get_p2p_fifo_endpoint(session: u32, fifo: u32, endpoint: *mut u32) -> i32;
672
673 #[link_name = "NiFpga_GetBitfileContents"]
674 pub fn get_bitfile_contents(session: u32, contents: *mut *const c_char) -> i32;
675
676 #[link_name = "NiFpga_ClientFunctionCall"]
677 pub fn client_function_call(
678 session: u32,
679 group: u32,
680 functionId: u32,
681 inBuffer: *const c_void,
682 inBufferSize: size_t,
683 outBuffer: *mut c_void,
684 outBufferSize: size_t,
685 ) -> i32;
686}