1use zerocopy::{FromBytes, Immutable, IntoBytes};
8
9pub const MAGMA_API_VERSION: u32 = 7;
10pub const MAGMA_VENDOR_ID_MALI: u32 = 5045;
11pub const MAGMA_VENDOR_ID_INTEL: u32 = 32902;
12pub type magma_query_t = u64;
13pub type magma_status_t = i32;
14pub type magma_cache_operation_t = u32;
15pub type magma_cache_policy_t = u32;
16pub type magma_format_t = u32;
17pub type magma_format_modifier_t = u64;
18pub type magma_colorspace_t = u32;
19pub type magma_coherency_domain_t = u32;
20pub type magma_buffer_range_op_t = u32;
21pub type magma_bool_t = u8;
22pub type magma_device_t = u64;
23pub type magma_buffer_t = u64;
24pub type magma_semaphore_t = u64;
25pub type magma_perf_count_pool_t = u64;
26pub type magma_connection_t = u64;
27pub type magma_sysmem_connection_t = u64;
28pub type magma_handle_t = u32;
29pub type magma_buffer_id_t = u64;
30pub type magma_semaphore_id_t = u64;
31#[repr(C)]
32#[derive(Copy, Clone)]
33pub struct magma_poll_item {
34 pub __bindgen_anon_1: magma_poll_item__bindgen_ty_1,
35 pub type_: u32,
36 pub condition: u32,
37 pub result: u32,
38 pub unused: u32,
39}
40#[repr(C)]
41#[derive(Copy, Clone)]
42pub union magma_poll_item__bindgen_ty_1 {
43 pub semaphore: magma_semaphore_t,
44 pub handle: magma_handle_t,
45}
46impl Default for magma_poll_item__bindgen_ty_1 {
47 fn default() -> Self {
48 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
49 unsafe {
50 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
51 s.assume_init()
52 }
53 }
54}
55impl Default for magma_poll_item {
56 fn default() -> Self {
57 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
58 unsafe {
59 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
60 s.assume_init()
61 }
62 }
63}
64pub type magma_poll_item_t = magma_poll_item;
65#[repr(C)]
66#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
67pub struct magma_exec_resource {
68 pub buffer_id: magma_buffer_id_t,
69 pub offset: u64,
70 pub length: u64,
71}
72pub type magma_exec_resource_t = magma_exec_resource;
73#[repr(C)]
74#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
75pub struct magma_exec_command_buffer {
76 pub resource_index: u32,
77 pub unused: u32,
78 pub start_offset: u64,
79}
80pub type magma_exec_command_buffer_t = magma_exec_command_buffer;
81#[repr(C)]
82#[derive(Debug, Copy, Clone)]
83pub struct magma_command_descriptor {
84 pub resource_count: u32,
85 pub command_buffer_count: u32,
86 pub wait_semaphore_count: u32,
87 pub signal_semaphore_count: u32,
88 pub resources: *mut magma_exec_resource,
89 pub command_buffers: *mut magma_exec_command_buffer,
90 pub semaphore_ids: *mut u64,
91 pub flags: u64,
92}
93impl Default for magma_command_descriptor {
94 fn default() -> Self {
95 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
96 unsafe {
97 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
98 s.assume_init()
99 }
100 }
101}
102pub type magma_command_descriptor_t = magma_command_descriptor;
103#[repr(C)]
104#[derive(Debug, Copy, Clone)]
105pub struct magma_inline_command_buffer {
106 pub data: *mut ::std::os::raw::c_void,
107 pub size: u64,
108 pub semaphore_ids: *mut u64,
109 pub semaphore_count: u32,
110 pub __bindgen_padding_0: [u8; 4usize],
111}
112impl Default for magma_inline_command_buffer {
113 fn default() -> Self {
114 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
115 unsafe {
116 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
117 s.assume_init()
118 }
119 }
120}
121pub type magma_inline_command_buffer_t = magma_inline_command_buffer;
122#[repr(C)]
123#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
124pub struct magma_total_time_query_result {
125 pub gpu_time_ns: u64,
126 pub monotonic_time_ns: u64,
127}
128pub type magma_total_time_query_result_t = magma_total_time_query_result;
129#[repr(C)]
130#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
131pub struct magma_buffer_offset {
132 pub buffer_id: u64,
133 pub offset: u64,
134 pub length: u64,
135}
136pub type magma_buffer_offset_t = magma_buffer_offset;
137#[repr(C)]
138#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
139pub struct magma_buffer_info {
140 pub committed_byte_count: u64,
141 pub size: u64,
142}
143pub type magma_buffer_info_t = magma_buffer_info;
144#[repr(C)]
145#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
146pub struct magma_image_create_info {
147 pub drm_format: u64,
148 pub drm_format_modifiers: [u64; 16usize],
149 pub width: u32,
150 pub height: u32,
151 pub flags: u64,
152}
153pub type magma_image_create_info_t = magma_image_create_info;
154#[repr(C)]
155#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
156pub struct magma_image_info {
157 pub plane_strides: [u64; 4usize],
158 pub plane_offsets: [u32; 4usize],
159 pub drm_format_modifier: u64,
160 pub coherency_domain: u32,
161 pub unused: u32,
162}
163pub type magma_image_info_t = magma_image_info;
164unsafe extern "C" {
165 #[doc = "\n \\brief Imports and takes ownership of a channel to a device. Takes ownership of |device_channel|\n on both success and failure.\n \\param device_channel A channel connecting to a gpu class device.\n \\param device_out Returned device.\n"]
166 pub fn magma_device_import(
167 device_channel: magma_handle_t,
168 device_out: *mut magma_device_t,
169 ) -> magma_status_t;
170}
171unsafe extern "C" {
172 #[doc = "\n \\brief Releases a handle to a device\n \\param device An open device.\n"]
173 pub fn magma_device_release(device: magma_device_t);
174}
175unsafe extern "C" {
176 #[doc = "\n \\brief Performs a query synchronously. On MAGMA_STATUS_OK, a given query |id| will return either\n a buffer in |result_buffer_out|, or a value in |result_out|. A NULL pointer may be\n provided for whichever result parameter is not needed.\n \\param device An open device.\n \\param id A vendor-specific ID.\n \\param result_buffer_out Handle to the returned buffer.\n \\param result_out Pointer to a uint64 result.\n"]
177 pub fn magma_device_query(
178 device: magma_device_t,
179 id: u64,
180 result_buffer_out: *mut magma_handle_t,
181 result_out: *mut u64,
182 ) -> magma_status_t;
183}
184unsafe extern "C" {
185 #[doc = "\n \\brief Opens a connection to a device.\n \\param device An open device\n \\param connection_out Returned connection.\n"]
186 pub fn magma_device_create_connection(
187 device: magma_device_t,
188 connection_out: *mut magma_connection_t,
189 ) -> magma_status_t;
190}
191unsafe extern "C" {
192 #[doc = "\n \\brief Releases the given connection.\n \\param connection An open connection.\n"]
193 pub fn magma_connection_release(connection: magma_connection_t);
194}
195unsafe extern "C" {
196 #[doc = "\n \\brief If a system driver error occurs, the connection will be closed, and this interface will\n eventually return the error. This interface does not flush messages that may be pending\n (see magma_connection_flush).\n \\param connection An open connection.\n"]
197 pub fn magma_connection_get_error(connection: magma_connection_t) -> magma_status_t;
198}
199unsafe extern "C" {
200 #[doc = "\n \\brief Creates a context on the given connection.\n \\param connection An open connection.\n \\param context_id_out The returned context id.\n"]
201 pub fn magma_connection_create_context(
202 connection: magma_connection_t,
203 context_id_out: *mut u32,
204 ) -> magma_status_t;
205}
206unsafe extern "C" {
207 #[doc = "\n \\brief Releases the context associated with the given id.\n \\param connection An open connection.\n \\param context_id A valid context id.\n"]
208 pub fn magma_connection_release_context(connection: magma_connection_t, context_id: u32);
209}
210unsafe extern "C" {
211 #[doc = "\n \\brief Creates a memory buffer of at least the given size.\n \\param connection An open connection.\n \\param size Requested buffer size.\n \\param size_out The returned buffer's actual size.\n \\param buffer_out The returned buffer.\n \\param id_out The buffer id of the buffer.\n"]
212 pub fn magma_connection_create_buffer(
213 connection: magma_connection_t,
214 size: u64,
215 size_out: *mut u64,
216 buffer_out: *mut magma_buffer_t,
217 id_out: *mut magma_buffer_id_t,
218 ) -> magma_status_t;
219}
220unsafe extern "C" {
221 #[doc = "\n \\brief Releases the given memory buffer.\n \\param connection An open connection.\n \\param buffer A valid buffer.\n"]
222 pub fn magma_connection_release_buffer(connection: magma_connection_t, buffer: magma_buffer_t);
223}
224unsafe extern "C" {
225 #[doc = "\n \\brief Imports and takes ownership of the buffer referred to by the given handle. Takes\n ownership of |buffer_handle| on both success and failure.\n \\param connection An open connection.\n \\param buffer_handle A valid handle.\n \\param size_out The size of the buffer in bytes.\n \\param buffer_out The returned buffer.\n \\param id_out The buffer id of the buffer.\n"]
226 pub fn magma_connection_import_buffer(
227 connection: magma_connection_t,
228 buffer_handle: magma_handle_t,
229 size_out: *mut u64,
230 buffer_out: *mut magma_buffer_t,
231 id_out: *mut magma_buffer_id_t,
232 ) -> magma_status_t;
233}
234unsafe extern "C" {
235 #[doc = "\n \\brief Creates a semaphore.\n \\param connection An open connection.\n \\param semaphore_out The returned semaphore.\n \\param id_out The id of the semaphore.\n"]
236 pub fn magma_connection_create_semaphore(
237 connection: magma_connection_t,
238 semaphore_out: *mut magma_semaphore_t,
239 id_out: *mut magma_semaphore_id_t,
240 ) -> magma_status_t;
241}
242unsafe extern "C" {
243 #[doc = "\n \\brief Releases the given semaphore.\n \\param connection An open connection.\n \\param semaphore A valid semaphore.\n"]
244 pub fn magma_connection_release_semaphore(
245 connection: magma_connection_t,
246 semaphore: magma_semaphore_t,
247 );
248}
249unsafe extern "C" {
250 #[doc = "\n \\brief Imports and takes ownership of the semaphore referred to by the given handle. Takes\n ownership of |semaphore_handle| on both success and failure.\n \\param connection An open connection.\n \\param semaphore_handle A valid semaphore handle.\n \\param flags Pass MAGMA_IMPORT_SEMAPHORE_ONESHOT to prevent auto-reset after wait.\n \\param semaphore_out The returned semaphore.\n \\param id_out The id of the semaphore.\n"]
251 pub fn magma_connection_import_semaphore2(
252 connection: magma_connection_t,
253 semaphore_handle: magma_handle_t,
254 flags: u64,
255 semaphore_out: *mut magma_semaphore_t,
256 id_out: *mut magma_semaphore_id_t,
257 ) -> magma_status_t;
258}
259unsafe extern "C" {
260 #[doc = "\n \\brief Perform an operation on a range of a buffer\n \\param connection An open connection.\n \\param buffer A valid buffer.\n \\param options Options for the operation.\n \\param start_offset Byte offset into the buffer.\n \\param length Length (in bytes) of the region to operate on.\n"]
261 pub fn magma_connection_perform_buffer_op(
262 connection: magma_connection_t,
263 buffer: magma_buffer_t,
264 options: u32,
265 start_offset: u64,
266 length: u64,
267 ) -> magma_status_t;
268}
269unsafe extern "C" {
270 #[doc = "\n \\brief Maps a buffer range onto the hardware in the connection's address space at the given\n address. Depending on the MSD this may automatically commit and populate that range.\n \\param connection An open connection.\n \\param hw_va Destination virtual address for the mapping.\n \\param buffer A valid buffer.\n \\param offset Offset into the buffer.\n \\param length Length in bytes of the range to map.\n \\param map_flags A valid MAGMA_MAP_FLAGS value.\n"]
271 pub fn magma_connection_map_buffer(
272 connection: magma_connection_t,
273 hw_va: u64,
274 buffer: magma_buffer_t,
275 offset: u64,
276 length: u64,
277 map_flags: u64,
278 ) -> magma_status_t;
279}
280unsafe extern "C" {
281 #[doc = "\n \\brief Releases the mapping at the given hardware address.\n \\param connection An open connection.\n \\param hw_va A hardware virtual address associated with an existing mapping of the given buffer.\n \\param buffer A valid buffer.\n"]
282 pub fn magma_connection_unmap_buffer(
283 connection: magma_connection_t,
284 hw_va: u64,
285 buffer: magma_buffer_t,
286 );
287}
288unsafe extern "C" {
289 #[doc = "\n \\brief Submits command buffers for execution on the hardware.\n \\param connection An open connection.\n \\param context_id A valid context id.\n \\param descriptor A pointer to the command descriptor.\n"]
290 pub fn magma_connection_execute_command(
291 connection: magma_connection_t,
292 context_id: u32,
293 descriptor: *mut magma_command_descriptor_t,
294 ) -> magma_status_t;
295}
296unsafe extern "C" {
297 #[doc = "\n \\brief Submits a series of commands for execution on the hardware without using a command\n buffer.\n \\param connection An open connection.\n \\param context_id A valid context ID.\n \\param command_count The number of commands in the provided buffer.\n \\param command_buffers An array of command_count magma_inline_command_buffer structs.\n"]
298 pub fn magma_connection_execute_immediate_commands(
299 connection: magma_connection_t,
300 context_id: u32,
301 command_count: u64,
302 command_buffers: *mut magma_inline_command_buffer_t,
303 ) -> magma_status_t;
304}
305unsafe extern "C" {
306 #[doc = "\n \\brief Submits a series of commands for execution on the hardware without using a command\n buffer.\n \\param connection An open connection.\n \\param context_id A valid context ID.\n \\param command_count The number of commands in the provided buffer.\n \\param command_buffers An array of command_count magma_inline_command_buffer structs.\n"]
307 pub fn magma_connection_execute_inline_commands(
308 connection: magma_connection_t,
309 context_id: u32,
310 command_count: u64,
311 command_buffers: *mut magma_inline_command_buffer_t,
312 ) -> magma_status_t;
313}
314unsafe extern "C" {
315 #[doc = "\n \\brief Incurs a round-trip to the system driver, used to ensure all previous messages have been\n observed, but not necessarily completed. If a system driver error occurs, the connection\n will be closed, and this interface will return the error.\n \\param connection An open connection.\n"]
316 pub fn magma_connection_flush(connection: magma_connection_t) -> magma_status_t;
317}
318unsafe extern "C" {
319 #[doc = "\n \\brief Returns a handle that can be waited on to determine when the connection has data in the\n notification channel. This channel has the same lifetime as the connection and must not\n be closed by the client.\n \\param connection An open connection.\n"]
320 pub fn magma_connection_get_notification_channel_handle(
321 connection: magma_connection_t,
322 ) -> magma_handle_t;
323}
324unsafe extern "C" {
325 #[doc = "\n \\brief Reads a notification from the channel into the given buffer. Message sizes may vary\n depending on the MSD. If the buffer provided is too small for the message,\n MAGMA_STATUS_INVALID_ARGS will be returned and the size of message will be returned in\n the buffer_size_out parameter.\n \\param connection An open connection.\n \\param buffer Buffer into which to read notification data.\n \\param buffer_size Size of the given buffer.\n \\param buffer_size_out Returned size of the notification data written to the buffer, or 0 if\n there are no messages pending.\n \\param more_data_out True if there is more notification data waiting.\n"]
326 pub fn magma_connection_read_notification_channel(
327 connection: magma_connection_t,
328 buffer: *mut ::std::os::raw::c_void,
329 buffer_size: u64,
330 buffer_size_out: *mut u64,
331 more_data_out: *mut magma_bool_t,
332 ) -> magma_status_t;
333}
334unsafe extern "C" {
335 #[doc = "\n \\brief Cleans, and optionally invalidates, the cache for the region of memory specified by the\n given buffer, offset, and size, and write the contents to ram.\n \\param buffer A valid buffer.\n \\param offset An offset into the buffer. Must be less than or equal to the buffer's size.\n \\param size Size of region to be cleaned. Offset + size must be less than or equal to the\n buffer's size.\n \\param operation One of MAGMA_CACHE_OPERATION_CLEAN or MAGMA_CACHE_OPERATION_CLEAN_INVALIDATE.\n"]
336 pub fn magma_buffer_clean_cache(
337 buffer: magma_buffer_t,
338 offset: u64,
339 size: u64,
340 operation: magma_cache_operation_t,
341 ) -> magma_status_t;
342}
343unsafe extern "C" {
344 #[doc = "\n \\brief Configures the cache for the given buffer.\n \\param buffer A valid buffer.\n \\param policy One of MAGMA_CACHE_POLICY_[CACHED|WRITE_COMBINING|UNCACHED].\n"]
345 pub fn magma_buffer_set_cache_policy(
346 buffer: magma_buffer_t,
347 policy: magma_cache_policy_t,
348 ) -> magma_status_t;
349}
350unsafe extern "C" {
351 #[doc = "\n \\brief Queries the cache policy for a buffer.\n \\param buffer A valid buffer.\n \\param cache_policy_out The returned cache policy.\n"]
352 pub fn magma_buffer_get_cache_policy(
353 buffer: magma_buffer_t,
354 cache_policy_out: *mut magma_cache_policy_t,
355 ) -> magma_status_t;
356}
357unsafe extern "C" {
358 #[doc = "\n \\brief Sets a name for the buffer for use in debugging tools.\n \\param buffer A valid buffer.\n \\param name The 0-terminated name of the buffer. May be truncated.\n"]
359 pub fn magma_buffer_set_name(
360 buffer: magma_buffer_t,
361 name: *const ::std::os::raw::c_char,
362 ) -> magma_status_t;
363}
364unsafe extern "C" {
365 #[doc = "\n \\brief Get information on a magma buffer\n \\param buffer A valid buffer.\n \\param info_out Pointer to struct that receives the buffer info.\n"]
366 pub fn magma_buffer_get_info(
367 buffer: magma_buffer_t,
368 info_out: *mut magma_buffer_info_t,
369 ) -> magma_status_t;
370}
371unsafe extern "C" {
372 #[doc = "\n \\brief Gets a platform handle for the given buffer. This can be used to perform a CPU mapping of\n the buffer using the standard syscall. The handle may be released without invalidating\n such CPU mappings.\n \\param buffer A valid buffer.\n \\param handle_out Pointer to the returned handle.\n"]
373 pub fn magma_buffer_get_handle(
374 buffer: magma_buffer_t,
375 handle_out: *mut magma_handle_t,
376 ) -> magma_status_t;
377}
378unsafe extern "C" {
379 #[doc = "\n \\brief Exports the given buffer, returning a handle that may be imported into a connection.\n \\param buffer A valid buffer.\n \\param buffer_handle_out The returned handle.\n"]
380 pub fn magma_buffer_export(
381 buffer: magma_buffer_t,
382 buffer_handle_out: *mut magma_handle_t,
383 ) -> magma_status_t;
384}
385unsafe extern "C" {
386 #[doc = "\n \\brief Signals the given semaphore.\n \\param semaphore A valid semaphore.\n"]
387 pub fn magma_semaphore_signal(semaphore: magma_semaphore_t);
388}
389unsafe extern "C" {
390 #[doc = "\n \\brief Resets the given semaphore.\n \\param semaphore A valid semaphore.\n"]
391 pub fn magma_semaphore_reset(semaphore: magma_semaphore_t);
392}
393unsafe extern "C" {
394 #[doc = "\n \\brief Exports the given semaphore, returning a handle that may be imported into a connection\n \\param semaphore A valid semaphore.\n \\param semaphore_handle_out The returned handle.\n"]
395 pub fn magma_semaphore_export(
396 semaphore: magma_semaphore_t,
397 semaphore_handle_out: *mut magma_handle_t,
398 ) -> magma_status_t;
399}
400unsafe extern "C" {
401 #[doc = "\n \\brief Waits for at least one of the given items to meet a condition. Does not reset any\n semaphores. When MAGMA_STATUS_OK is returned, results are returned in the items array.\n MAGMA_STATUS_TIMED_OUT is returned if no conditions are met before the given timeout\n expires. If the notification channel handle is included in the item list, and the magma\n connection is closed, then MAGMA_STATUS_CONNECTION_LOST is returned.\n \\param items Array of poll items. Type should be either MAGMA_POLL_TYPE_SEMAPHORE or\n MAGMA_POLL_TYPE_HANDLE. Condition may be set to MAGMA_POLL_CONDITION_SIGNALED OR\n MAGMA_POLL_CONDITION_READABLE. If condition is 0 the item is ignored. Item results are\n set to the condition that was satisfied, otherwise 0. If the same item is given twice the\n behavior is undefined.\n \\param count Number of poll items in the array.\n \\param timeout_ns Time in ns to wait before returning MAGMA_STATUS_TIMED_OUT.\n"]
402 pub fn magma_poll(items: *mut magma_poll_item_t, count: u32, timeout_ns: u64)
403 -> magma_status_t;
404}
405unsafe extern "C" {
406 #[doc = "\n \\brief Initializes tracing. This should be called on Fuchsia; on other platforms it's not needed\n and will just close the given handle.\n \\param channel An open connection to a tracing provider.\n"]
407 pub fn magma_initialize_tracing(channel: magma_handle_t) -> magma_status_t;
408}
409unsafe extern "C" {
410 #[doc = "\n \\brief Initializes logging, used for debug and some exceptional error reporting. This should be\n called on Fuchsia; on other platforms it's not needed and will just close the given\n handle.\n \\param channel An open connection to the syslog service.\n"]
411 pub fn magma_initialize_logging(channel: magma_handle_t) -> magma_status_t;
412}
413unsafe extern "C" {
414 #[doc = "\n \\brief Tries to enable access to performance counters. Returns MAGMA_STATUS_OK if counters were\n successfully enabled or MAGMA_STATUS_ACCESS_DENIED if channel is for the wrong device and\n counters were not successfully enabled previously.\n \\param connection An open connection to a device.\n \\param channel A handle to a channel to a gpu-performance-counter device.\n"]
415 pub fn magma_connection_enable_performance_counter_access(
416 connection: magma_connection_t,
417 channel: magma_handle_t,
418 ) -> magma_status_t;
419}
420unsafe extern "C" {
421 #[doc = "\n \\brief Enables a set of performance counters (the precise definition depends on the driver).\n Disables enabled performance counters that are not in the new set. Performance counters\n will also be automatically disabled on connection close. Performance counter access must\n have been enabled using magma_connection_enable_performance_counter_access before calling\n this method.\n \\param connection An open connection to a device.\n \\param counters An implementation-defined list of counters.\n \\param counters_count The number of entries in |counters|.\n"]
422 pub fn magma_connection_enable_performance_counters(
423 connection: magma_connection_t,
424 counters: *mut u64,
425 counters_count: u64,
426 ) -> magma_status_t;
427}
428unsafe extern "C" {
429 #[doc = "\n \\brief Create a pool of buffers that performance counters can be dumped into. Performance\n counter access must have been enabled using\n magma_connection_enable_performance_counter_access before calling this method.\n \\param connection An open connection to a device.\n \\param pool_id_out A new pool id. Must not currently be in use.\n \\param notification_handle_out A handle that should be waited on.\n"]
430 pub fn magma_connection_create_performance_counter_buffer_pool(
431 connection: magma_connection_t,
432 pool_id_out: *mut magma_perf_count_pool_t,
433 notification_handle_out: *mut magma_handle_t,
434 ) -> magma_status_t;
435}
436unsafe extern "C" {
437 #[doc = "\n \\brief Releases a pool of performance counter buffers. Performance counter access must have been\n enabled using magma_connection_enable_performance_counter_access before calling this\n method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool id.\n"]
438 pub fn magma_connection_release_performance_counter_buffer_pool(
439 connection: magma_connection_t,
440 pool_id: magma_perf_count_pool_t,
441 ) -> magma_status_t;
442}
443unsafe extern "C" {
444 #[doc = "\n \\brief Adds a an array of buffers + offset to the pool. |offsets[n].buffer_id| is the koid of a\n buffer that was previously imported using ImportBuffer(). The same buffer may be added to\n multiple pools. The pool will hold on to a reference to the buffer even after\n ReleaseBuffer is called. When dumped into this entry, counters will be written starting\n at |offsets[n].offset| bytes into the buffer, and up to |offsets[n].offset| +\n |offsets[n].size|. |offsets[n].size| must be large enough to fit all enabled counters.\n Performance counter access must have been enabled using\n magma_connection_enable_performance_counter_access before calling this method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool.\n \\param offsets An array of offsets to add.\n \\param offsets_count The number of elements in offsets.\n"]
445 pub fn magma_connection_add_performance_counter_buffer_offsets_to_pool(
446 connection: magma_connection_t,
447 pool_id: magma_perf_count_pool_t,
448 offsets: *const magma_buffer_offset_t,
449 offsets_count: u64,
450 ) -> magma_status_t;
451}
452unsafe extern "C" {
453 #[doc = "\n \\brief Removes every offset of a buffer from the pool. Performance counter access must have been\n enabled using magma_connection_enable_performance_counter_access before calling this\n method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool.\n \\param buffer A magma_buffer\n"]
454 pub fn magma_connection_remove_performance_counter_buffer_from_pool(
455 connection: magma_connection_t,
456 pool_id: magma_perf_count_pool_t,
457 buffer: magma_buffer_t,
458 ) -> magma_status_t;
459}
460unsafe extern "C" {
461 #[doc = "\n \\brief Triggers dumping of the performance counters into a buffer pool. May fail silently if\n there are no buffers in the pool. |trigger_id| is an arbitrary ID assigned by the client\n that can be returned in OnPerformanceCounterReadCompleted. Performance counter access\n must have been enabled using magma_connection_enable_performance_counter_access before\n calling this method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool\n \\param trigger_id An arbitrary ID assigned by the client that will be returned in\n OnPerformanceCounterReadCompleted.\n"]
462 pub fn magma_connection_dump_performance_counters(
463 connection: magma_connection_t,
464 pool_id: magma_perf_count_pool_t,
465 trigger_id: u32,
466 ) -> magma_status_t;
467}
468unsafe extern "C" {
469 #[doc = "\n \\brief Sets the values of all listed performance counters to 0. May not be supported by some\n hardware. Performance counter access must have been enabled using\n magma_connection_enable_performance_counter_access before calling this method.\n \\param connection An open connection to a device.\n \\param counters An implementation-defined list of counters.\n \\param counters_count The number of entries in |counters|.\n"]
470 pub fn magma_connection_clear_performance_counters(
471 connection: magma_connection_t,
472 counters: *mut u64,
473 counters_count: u64,
474 ) -> magma_status_t;
475}
476unsafe extern "C" {
477 #[doc = "\n \\brief Reads one performance counter completion event, if available.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool.\n \\param trigger_id_out The trigger ID for this event.\n \\param buffer_id_out The buffer ID for this event.\n \\param buffer_offset_out The buffer offset for this event.\n \\param time_out The monotonic time this event happened.\n \\param result_flags_out A set of flags giving more information about this event.\n"]
478 pub fn magma_connection_read_performance_counter_completion(
479 connection: magma_connection_t,
480 pool_id: magma_perf_count_pool_t,
481 trigger_id_out: *mut u32,
482 buffer_id_out: *mut u64,
483 buffer_offset_out: *mut u32,
484 time_out: *mut u64,
485 result_flags_out: *mut u32,
486 ) -> magma_status_t;
487}
488unsafe extern "C" {
489 #[doc = "\n \\brief Creates an image buffer backed by a buffer collection given a DRM format and optional\n modifier, as specified in the create info.\n \\param connection An open connection.\n \\param create_info Input parameters describing the image.\n \\param size_out The size of the image buffer in bytes\n \\param image_out The image buffer.\n \\param buffer_id_out The ID of the image buffer.\n"]
490 pub fn magma_virt_connection_create_image(
491 connection: magma_connection_t,
492 create_info: *mut magma_image_create_info_t,
493 size_out: *mut u64,
494 image_out: *mut magma_buffer_t,
495 buffer_id_out: *mut magma_buffer_id_t,
496 ) -> magma_status_t;
497}
498unsafe extern "C" {
499 #[doc = "\n \\brief Returns parameters for an image created with virtmagma_create_image.\n \\param connection An open connection.\n \\param image The image buffer.\n \\param image_info_out Output parameters describing the image.\n"]
500 pub fn magma_virt_connection_get_image_info(
501 connection: magma_connection_t,
502 image: magma_buffer_t,
503 image_info_out: *mut magma_image_info_t,
504 ) -> magma_status_t;
505}
506pub type __u32 = ::std::os::raw::c_uint;
507pub type __u64 = ::std::os::raw::c_ulonglong;
508#[repr(C)]
509#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
510pub struct virtmagma_ioctl_args_handshake {
511 pub handshake_inout: __u32,
512 pub version_out: __u32,
513}
514#[repr(C)]
515#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
516pub struct virtmagma_ioctl_args_magma_command {
517 pub request_address: __u64,
518 pub request_size: __u64,
519 pub response_address: __u64,
520 pub response_size: __u64,
521}
522#[repr(C)]
523#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
524pub struct virtmagma_command_descriptor {
525 pub descriptor_size: __u64,
526 pub descriptor: __u64,
527 pub resource_size: __u64,
528 pub resources: __u64,
529 pub command_buffer_size: __u64,
530 pub command_buffers: __u64,
531 pub semaphore_size: __u64,
532 pub semaphores: __u64,
533}
534#[repr(C)]
535#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
536pub struct virtmagma_create_image_wrapper {
537 pub create_info: __u64,
538 pub create_info_size: __u64,
539}
540#[repr(C)]
541#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
542pub struct virtmagma_get_image_info_wrapper {
543 pub image_info_out: __u64,
544 pub image_info_size: __u64,
545}
546#[repr(C)]
547#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
548pub struct virtmagma_buffer_set_name_wrapper {
549 pub name_address: __u64,
550 pub name_size: __u64,
551}
552#[repr(C, packed)]
553#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
554pub struct virtio_magma_config {
555 pub dummy: u64,
556}
557pub type virtio_magma_config_t = virtio_magma_config;
558pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_IMPORT: virtio_magma_ctrl_type = 4142;
559pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_RELEASE: virtio_magma_ctrl_type = 4143;
560pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_QUERY: virtio_magma_ctrl_type = 4177;
561pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_CREATE_CONNECTION: virtio_magma_ctrl_type =
562 4146;
563pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE: virtio_magma_ctrl_type = 4100;
564pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_GET_ERROR: virtio_magma_ctrl_type =
565 4101;
566pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_CONTEXT:
567 virtio_magma_ctrl_type = 4102;
568pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_CONTEXT:
569 virtio_magma_ctrl_type = 4103;
570pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_BUFFER: virtio_magma_ctrl_type =
571 4181;
572pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_BUFFER:
573 virtio_magma_ctrl_type = 4105;
574pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_IMPORT_BUFFER: virtio_magma_ctrl_type =
575 4180;
576pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_SEMAPHORE:
577 virtio_magma_ctrl_type = 4185;
578pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_SEMAPHORE:
579 virtio_magma_ctrl_type = 4131;
580pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_IMPORT_SEMAPHORE2:
581 virtio_magma_ctrl_type = 4187;
582pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_PERFORM_BUFFER_OP:
583 virtio_magma_ctrl_type = 4161;
584pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_MAP_BUFFER: virtio_magma_ctrl_type =
585 4178;
586pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_UNMAP_BUFFER: virtio_magma_ctrl_type =
587 4179;
588pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_EXECUTE_COMMAND:
589 virtio_magma_ctrl_type = 4176;
590pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_EXECUTE_IMMEDIATE_COMMANDS:
591 virtio_magma_ctrl_type = 4129;
592pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_EXECUTE_INLINE_COMMANDS:
593 virtio_magma_ctrl_type = 4130;
594pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_FLUSH: virtio_magma_ctrl_type = 4175;
595pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_GET_NOTIFICATION_CHANNEL_HANDLE:
596 virtio_magma_ctrl_type = 4138;
597pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_READ_NOTIFICATION_CHANNEL:
598 virtio_magma_ctrl_type = 4166;
599pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_CLEAN_CACHE: virtio_magma_ctrl_type = 4110;
600pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_SET_CACHE_POLICY: virtio_magma_ctrl_type =
601 4111;
602pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_GET_CACHE_POLICY: virtio_magma_ctrl_type =
603 4112;
604pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_SET_NAME: virtio_magma_ctrl_type = 4160;
605pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_GET_INFO: virtio_magma_ctrl_type = 4162;
606pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_GET_HANDLE: virtio_magma_ctrl_type = 4171;
607pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_EXPORT: virtio_magma_ctrl_type = 4183;
608pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SEMAPHORE_SIGNAL: virtio_magma_ctrl_type = 4133;
609pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SEMAPHORE_RESET: virtio_magma_ctrl_type = 4134;
610pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SEMAPHORE_EXPORT: virtio_magma_ctrl_type = 4184;
611pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_POLL: virtio_magma_ctrl_type = 4148;
612pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INITIALIZE_TRACING: virtio_magma_ctrl_type = 4141;
613pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INITIALIZE_LOGGING: virtio_magma_ctrl_type = 4147;
614pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_ENABLE_PERFORMANCE_COUNTER_ACCESS:
615 virtio_magma_ctrl_type = 4149;
616pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_ENABLE_PERFORMANCE_COUNTERS:
617 virtio_magma_ctrl_type = 4152;
618pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 4153 ;
619pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 4154 ;
620pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_ADD_PERFORMANCE_COUNTER_BUFFER_OFFSETS_TO_POOL : virtio_magma_ctrl_type = 4155 ;
621pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_REMOVE_PERFORMANCE_COUNTER_BUFFER_FROM_POOL : virtio_magma_ctrl_type = 4156 ;
622pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_DUMP_PERFORMANCE_COUNTERS:
623 virtio_magma_ctrl_type = 4157;
624pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CLEAR_PERFORMANCE_COUNTERS:
625 virtio_magma_ctrl_type = 4158;
626pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_READ_PERFORMANCE_COUNTER_COMPLETION:
627 virtio_magma_ctrl_type = 4159;
628pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_VIRT_CONNECTION_CREATE_IMAGE:
629 virtio_magma_ctrl_type = 4182;
630pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_VIRT_CONNECTION_GET_IMAGE_INFO:
631 virtio_magma_ctrl_type = 4168;
632pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INTERNAL_RELEASE_HANDLE: virtio_magma_ctrl_type =
633 4172;
634pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INTERNAL_MAP: virtio_magma_ctrl_type = 4173;
635pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INTERNAL_UNMAP: virtio_magma_ctrl_type = 4174;
636pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_IMPORT: virtio_magma_ctrl_type = 8238;
637pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_RELEASE: virtio_magma_ctrl_type = 8239;
638pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_QUERY: virtio_magma_ctrl_type = 8273;
639pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_CREATE_CONNECTION:
640 virtio_magma_ctrl_type = 8242;
641pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE: virtio_magma_ctrl_type =
642 8196;
643pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_GET_ERROR: virtio_magma_ctrl_type =
644 8197;
645pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_CONTEXT:
646 virtio_magma_ctrl_type = 8198;
647pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_CONTEXT:
648 virtio_magma_ctrl_type = 8199;
649pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_BUFFER:
650 virtio_magma_ctrl_type = 8277;
651pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_BUFFER:
652 virtio_magma_ctrl_type = 8201;
653pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_IMPORT_BUFFER:
654 virtio_magma_ctrl_type = 8276;
655pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_SEMAPHORE:
656 virtio_magma_ctrl_type = 8281;
657pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_SEMAPHORE:
658 virtio_magma_ctrl_type = 8227;
659pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_IMPORT_SEMAPHORE2:
660 virtio_magma_ctrl_type = 8283;
661pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_PERFORM_BUFFER_OP:
662 virtio_magma_ctrl_type = 8257;
663pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_MAP_BUFFER: virtio_magma_ctrl_type =
664 8274;
665pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_UNMAP_BUFFER: virtio_magma_ctrl_type =
666 8275;
667pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_EXECUTE_COMMAND:
668 virtio_magma_ctrl_type = 8272;
669pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_EXECUTE_IMMEDIATE_COMMANDS:
670 virtio_magma_ctrl_type = 8225;
671pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_EXECUTE_INLINE_COMMANDS:
672 virtio_magma_ctrl_type = 8226;
673pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_FLUSH: virtio_magma_ctrl_type = 8271;
674pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_GET_NOTIFICATION_CHANNEL_HANDLE:
675 virtio_magma_ctrl_type = 8234;
676pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_READ_NOTIFICATION_CHANNEL:
677 virtio_magma_ctrl_type = 8262;
678pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_CLEAN_CACHE: virtio_magma_ctrl_type =
679 8206;
680pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_SET_CACHE_POLICY: virtio_magma_ctrl_type =
681 8207;
682pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_GET_CACHE_POLICY: virtio_magma_ctrl_type =
683 8208;
684pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_SET_NAME: virtio_magma_ctrl_type = 8256;
685pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_GET_INFO: virtio_magma_ctrl_type = 8258;
686pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_GET_HANDLE: virtio_magma_ctrl_type = 8267;
687pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_EXPORT: virtio_magma_ctrl_type = 8279;
688pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SEMAPHORE_SIGNAL: virtio_magma_ctrl_type = 8229;
689pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SEMAPHORE_RESET: virtio_magma_ctrl_type = 8230;
690pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SEMAPHORE_EXPORT: virtio_magma_ctrl_type = 8280;
691pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_POLL: virtio_magma_ctrl_type = 8244;
692pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INITIALIZE_TRACING: virtio_magma_ctrl_type =
693 8237;
694pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INITIALIZE_LOGGING: virtio_magma_ctrl_type =
695 8243;
696pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_ENABLE_PERFORMANCE_COUNTER_ACCESS:
697 virtio_magma_ctrl_type = 8245;
698pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_ENABLE_PERFORMANCE_COUNTERS:
699 virtio_magma_ctrl_type = 8248;
700pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 8249 ;
701pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 8250 ;
702pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_ADD_PERFORMANCE_COUNTER_BUFFER_OFFSETS_TO_POOL : virtio_magma_ctrl_type = 8251 ;
703pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_REMOVE_PERFORMANCE_COUNTER_BUFFER_FROM_POOL : virtio_magma_ctrl_type = 8252 ;
704pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_DUMP_PERFORMANCE_COUNTERS:
705 virtio_magma_ctrl_type = 8253;
706pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CLEAR_PERFORMANCE_COUNTERS:
707 virtio_magma_ctrl_type = 8254;
708pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_READ_PERFORMANCE_COUNTER_COMPLETION : virtio_magma_ctrl_type = 8255 ;
709pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_VIRT_CONNECTION_CREATE_IMAGE:
710 virtio_magma_ctrl_type = 8278;
711pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_VIRT_CONNECTION_GET_IMAGE_INFO:
712 virtio_magma_ctrl_type = 8264;
713pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INTERNAL_RELEASE_HANDLE: virtio_magma_ctrl_type =
714 8268;
715pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INTERNAL_MAP: virtio_magma_ctrl_type = 8269;
716pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INTERNAL_UNMAP: virtio_magma_ctrl_type = 8270;
717pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_UNIMPLEMENTED: virtio_magma_ctrl_type =
718 12289;
719pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_INTERNAL: virtio_magma_ctrl_type = 12290;
720pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_HOST_DISCONNECTED: virtio_magma_ctrl_type =
721 12291;
722pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_OUT_OF_MEMORY: virtio_magma_ctrl_type =
723 12292;
724pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND: virtio_magma_ctrl_type =
725 12293;
726pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_INVALID_ARGUMENT: virtio_magma_ctrl_type =
727 12294;
728pub type virtio_magma_ctrl_type = ::std::os::raw::c_ushort;
729#[repr(C, packed)]
730#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
731pub struct virtio_magma_ctrl_hdr {
732 pub type_: u32,
733 pub flags: u32,
734}
735pub type virtio_magma_ctrl_hdr_t = virtio_magma_ctrl_hdr;
736#[repr(C, packed)]
737#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
738pub struct virtio_magma_device_import_ctrl {
739 pub hdr: virtio_magma_ctrl_hdr_t,
740 pub device_channel: u32,
741}
742pub type virtio_magma_device_import_ctrl_t = virtio_magma_device_import_ctrl;
743#[repr(C, packed)]
744#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
745pub struct virtio_magma_device_import_resp {
746 pub hdr: virtio_magma_ctrl_hdr_t,
747 pub device_out: u64,
748 pub result_return: u64,
749}
750pub type virtio_magma_device_import_resp_t = virtio_magma_device_import_resp;
751#[repr(C, packed)]
752#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
753pub struct virtio_magma_device_release_ctrl {
754 pub hdr: virtio_magma_ctrl_hdr_t,
755 pub device: u64,
756}
757pub type virtio_magma_device_release_ctrl_t = virtio_magma_device_release_ctrl;
758#[repr(C, packed)]
759#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
760pub struct virtio_magma_device_release_resp {
761 pub hdr: virtio_magma_ctrl_hdr_t,
762}
763pub type virtio_magma_device_release_resp_t = virtio_magma_device_release_resp;
764#[repr(C, packed)]
765#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
766pub struct virtio_magma_device_query_ctrl {
767 pub hdr: virtio_magma_ctrl_hdr_t,
768 pub device: u64,
769 pub id: u64,
770}
771pub type virtio_magma_device_query_ctrl_t = virtio_magma_device_query_ctrl;
772#[repr(C, packed)]
773#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
774pub struct virtio_magma_device_query_resp {
775 pub hdr: virtio_magma_ctrl_hdr_t,
776 pub result_buffer_out: u64,
777 pub result_out: u64,
778 pub result_return: u64,
779}
780pub type virtio_magma_device_query_resp_t = virtio_magma_device_query_resp;
781#[repr(C, packed)]
782#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
783pub struct virtio_magma_device_create_connection_ctrl {
784 pub hdr: virtio_magma_ctrl_hdr_t,
785 pub device: u64,
786}
787pub type virtio_magma_device_create_connection_ctrl_t = virtio_magma_device_create_connection_ctrl;
788#[repr(C, packed)]
789#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
790pub struct virtio_magma_device_create_connection_resp {
791 pub hdr: virtio_magma_ctrl_hdr_t,
792 pub connection_out: u64,
793 pub result_return: u64,
794}
795pub type virtio_magma_device_create_connection_resp_t = virtio_magma_device_create_connection_resp;
796#[repr(C, packed)]
797#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
798pub struct virtio_magma_connection_release_ctrl {
799 pub hdr: virtio_magma_ctrl_hdr_t,
800 pub connection: u64,
801}
802pub type virtio_magma_connection_release_ctrl_t = virtio_magma_connection_release_ctrl;
803#[repr(C, packed)]
804#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
805pub struct virtio_magma_connection_release_resp {
806 pub hdr: virtio_magma_ctrl_hdr_t,
807}
808pub type virtio_magma_connection_release_resp_t = virtio_magma_connection_release_resp;
809#[repr(C, packed)]
810#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
811pub struct virtio_magma_connection_get_error_ctrl {
812 pub hdr: virtio_magma_ctrl_hdr_t,
813 pub connection: u64,
814}
815pub type virtio_magma_connection_get_error_ctrl_t = virtio_magma_connection_get_error_ctrl;
816#[repr(C, packed)]
817#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
818pub struct virtio_magma_connection_get_error_resp {
819 pub hdr: virtio_magma_ctrl_hdr_t,
820 pub result_return: u64,
821}
822pub type virtio_magma_connection_get_error_resp_t = virtio_magma_connection_get_error_resp;
823#[repr(C, packed)]
824#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
825pub struct virtio_magma_connection_create_context_ctrl {
826 pub hdr: virtio_magma_ctrl_hdr_t,
827 pub connection: u64,
828}
829pub type virtio_magma_connection_create_context_ctrl_t =
830 virtio_magma_connection_create_context_ctrl;
831#[repr(C, packed)]
832#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
833pub struct virtio_magma_connection_create_context_resp {
834 pub hdr: virtio_magma_ctrl_hdr_t,
835 pub context_id_out: u64,
836 pub result_return: u64,
837}
838pub type virtio_magma_connection_create_context_resp_t =
839 virtio_magma_connection_create_context_resp;
840#[repr(C, packed)]
841#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
842pub struct virtio_magma_connection_release_context_ctrl {
843 pub hdr: virtio_magma_ctrl_hdr_t,
844 pub connection: u64,
845 pub context_id: u32,
846}
847pub type virtio_magma_connection_release_context_ctrl_t =
848 virtio_magma_connection_release_context_ctrl;
849#[repr(C, packed)]
850#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
851pub struct virtio_magma_connection_release_context_resp {
852 pub hdr: virtio_magma_ctrl_hdr_t,
853}
854pub type virtio_magma_connection_release_context_resp_t =
855 virtio_magma_connection_release_context_resp;
856#[repr(C, packed)]
857#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
858pub struct virtio_magma_connection_create_buffer_ctrl {
859 pub hdr: virtio_magma_ctrl_hdr_t,
860 pub connection: u64,
861 pub size: u64,
862}
863pub type virtio_magma_connection_create_buffer_ctrl_t = virtio_magma_connection_create_buffer_ctrl;
864#[repr(C, packed)]
865#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
866pub struct virtio_magma_connection_create_buffer_resp {
867 pub hdr: virtio_magma_ctrl_hdr_t,
868 pub size_out: u64,
869 pub buffer_out: u64,
870 pub id_out: u64,
871 pub result_return: u64,
872}
873pub type virtio_magma_connection_create_buffer_resp_t = virtio_magma_connection_create_buffer_resp;
874#[repr(C, packed)]
875#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
876pub struct virtio_magma_connection_release_buffer_ctrl {
877 pub hdr: virtio_magma_ctrl_hdr_t,
878 pub connection: u64,
879 pub buffer: u64,
880}
881pub type virtio_magma_connection_release_buffer_ctrl_t =
882 virtio_magma_connection_release_buffer_ctrl;
883#[repr(C, packed)]
884#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
885pub struct virtio_magma_connection_release_buffer_resp {
886 pub hdr: virtio_magma_ctrl_hdr_t,
887}
888pub type virtio_magma_connection_release_buffer_resp_t =
889 virtio_magma_connection_release_buffer_resp;
890#[repr(C, packed)]
891#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
892pub struct virtio_magma_connection_import_buffer_ctrl {
893 pub hdr: virtio_magma_ctrl_hdr_t,
894 pub connection: u64,
895 pub buffer_handle: u32,
896}
897pub type virtio_magma_connection_import_buffer_ctrl_t = virtio_magma_connection_import_buffer_ctrl;
898#[repr(C, packed)]
899#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
900pub struct virtio_magma_connection_import_buffer_resp {
901 pub hdr: virtio_magma_ctrl_hdr_t,
902 pub size_out: u64,
903 pub buffer_out: u64,
904 pub id_out: u64,
905 pub result_return: u64,
906}
907pub type virtio_magma_connection_import_buffer_resp_t = virtio_magma_connection_import_buffer_resp;
908#[repr(C, packed)]
909#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
910pub struct virtio_magma_connection_create_semaphore_ctrl {
911 pub hdr: virtio_magma_ctrl_hdr_t,
912 pub connection: u64,
913}
914pub type virtio_magma_connection_create_semaphore_ctrl_t =
915 virtio_magma_connection_create_semaphore_ctrl;
916#[repr(C, packed)]
917#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
918pub struct virtio_magma_connection_create_semaphore_resp {
919 pub hdr: virtio_magma_ctrl_hdr_t,
920 pub semaphore_out: u64,
921 pub id_out: u64,
922 pub result_return: u64,
923}
924pub type virtio_magma_connection_create_semaphore_resp_t =
925 virtio_magma_connection_create_semaphore_resp;
926#[repr(C, packed)]
927#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
928pub struct virtio_magma_connection_release_semaphore_ctrl {
929 pub hdr: virtio_magma_ctrl_hdr_t,
930 pub connection: u64,
931 pub semaphore: u64,
932}
933pub type virtio_magma_connection_release_semaphore_ctrl_t =
934 virtio_magma_connection_release_semaphore_ctrl;
935#[repr(C, packed)]
936#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
937pub struct virtio_magma_connection_release_semaphore_resp {
938 pub hdr: virtio_magma_ctrl_hdr_t,
939}
940pub type virtio_magma_connection_release_semaphore_resp_t =
941 virtio_magma_connection_release_semaphore_resp;
942#[repr(C, packed)]
943#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
944pub struct virtio_magma_connection_import_semaphore2_ctrl {
945 pub hdr: virtio_magma_ctrl_hdr_t,
946 pub connection: u64,
947 pub semaphore_handle: u32,
948 pub flags: u64,
949}
950pub type virtio_magma_connection_import_semaphore2_ctrl_t =
951 virtio_magma_connection_import_semaphore2_ctrl;
952#[repr(C, packed)]
953#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
954pub struct virtio_magma_connection_import_semaphore2_resp {
955 pub hdr: virtio_magma_ctrl_hdr_t,
956 pub semaphore_out: u64,
957 pub id_out: u64,
958 pub result_return: u64,
959}
960pub type virtio_magma_connection_import_semaphore2_resp_t =
961 virtio_magma_connection_import_semaphore2_resp;
962#[repr(C, packed)]
963#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
964pub struct virtio_magma_connection_perform_buffer_op_ctrl {
965 pub hdr: virtio_magma_ctrl_hdr_t,
966 pub connection: u64,
967 pub buffer: u64,
968 pub options: u32,
969 pub start_offset: u64,
970 pub length: u64,
971}
972pub type virtio_magma_connection_perform_buffer_op_ctrl_t =
973 virtio_magma_connection_perform_buffer_op_ctrl;
974#[repr(C, packed)]
975#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
976pub struct virtio_magma_connection_perform_buffer_op_resp {
977 pub hdr: virtio_magma_ctrl_hdr_t,
978 pub result_return: u64,
979}
980pub type virtio_magma_connection_perform_buffer_op_resp_t =
981 virtio_magma_connection_perform_buffer_op_resp;
982#[repr(C, packed)]
983#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
984pub struct virtio_magma_connection_map_buffer_ctrl {
985 pub hdr: virtio_magma_ctrl_hdr_t,
986 pub connection: u64,
987 pub hw_va: u64,
988 pub buffer: u64,
989 pub offset: u64,
990 pub length: u64,
991 pub map_flags: u64,
992}
993pub type virtio_magma_connection_map_buffer_ctrl_t = virtio_magma_connection_map_buffer_ctrl;
994#[repr(C, packed)]
995#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
996pub struct virtio_magma_connection_map_buffer_resp {
997 pub hdr: virtio_magma_ctrl_hdr_t,
998 pub result_return: u64,
999}
1000pub type virtio_magma_connection_map_buffer_resp_t = virtio_magma_connection_map_buffer_resp;
1001#[repr(C, packed)]
1002#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1003pub struct virtio_magma_connection_unmap_buffer_ctrl {
1004 pub hdr: virtio_magma_ctrl_hdr_t,
1005 pub connection: u64,
1006 pub hw_va: u64,
1007 pub buffer: u64,
1008}
1009pub type virtio_magma_connection_unmap_buffer_ctrl_t = virtio_magma_connection_unmap_buffer_ctrl;
1010#[repr(C, packed)]
1011#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1012pub struct virtio_magma_connection_unmap_buffer_resp {
1013 pub hdr: virtio_magma_ctrl_hdr_t,
1014}
1015pub type virtio_magma_connection_unmap_buffer_resp_t = virtio_magma_connection_unmap_buffer_resp;
1016#[repr(C, packed)]
1017#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1018pub struct virtio_magma_connection_execute_command_ctrl {
1019 pub hdr: virtio_magma_ctrl_hdr_t,
1020 pub connection: u64,
1021 pub context_id: u32,
1022 pub descriptor: u64,
1023}
1024pub type virtio_magma_connection_execute_command_ctrl_t =
1025 virtio_magma_connection_execute_command_ctrl;
1026#[repr(C, packed)]
1027#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1028pub struct virtio_magma_connection_execute_command_resp {
1029 pub hdr: virtio_magma_ctrl_hdr_t,
1030 pub result_return: u64,
1031}
1032pub type virtio_magma_connection_execute_command_resp_t =
1033 virtio_magma_connection_execute_command_resp;
1034#[repr(C, packed)]
1035#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1036pub struct virtio_magma_connection_execute_immediate_commands_ctrl {
1037 pub hdr: virtio_magma_ctrl_hdr_t,
1038 pub connection: u64,
1039 pub context_id: u32,
1040 pub command_count: u64,
1041 pub command_buffers: u64,
1042}
1043pub type virtio_magma_connection_execute_immediate_commands_ctrl_t =
1044 virtio_magma_connection_execute_immediate_commands_ctrl;
1045#[repr(C, packed)]
1046#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1047pub struct virtio_magma_connection_execute_immediate_commands_resp {
1048 pub hdr: virtio_magma_ctrl_hdr_t,
1049 pub result_return: u64,
1050}
1051pub type virtio_magma_connection_execute_immediate_commands_resp_t =
1052 virtio_magma_connection_execute_immediate_commands_resp;
1053#[repr(C, packed)]
1054#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1055pub struct virtio_magma_connection_execute_inline_commands_ctrl {
1056 pub hdr: virtio_magma_ctrl_hdr_t,
1057 pub connection: u64,
1058 pub context_id: u32,
1059 pub command_count: u64,
1060 pub command_buffers: u64,
1061}
1062pub type virtio_magma_connection_execute_inline_commands_ctrl_t =
1063 virtio_magma_connection_execute_inline_commands_ctrl;
1064#[repr(C, packed)]
1065#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1066pub struct virtio_magma_connection_execute_inline_commands_resp {
1067 pub hdr: virtio_magma_ctrl_hdr_t,
1068 pub result_return: u64,
1069}
1070pub type virtio_magma_connection_execute_inline_commands_resp_t =
1071 virtio_magma_connection_execute_inline_commands_resp;
1072#[repr(C, packed)]
1073#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1074pub struct virtio_magma_connection_flush_ctrl {
1075 pub hdr: virtio_magma_ctrl_hdr_t,
1076 pub connection: u64,
1077}
1078pub type virtio_magma_connection_flush_ctrl_t = virtio_magma_connection_flush_ctrl;
1079#[repr(C, packed)]
1080#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1081pub struct virtio_magma_connection_flush_resp {
1082 pub hdr: virtio_magma_ctrl_hdr_t,
1083 pub result_return: u64,
1084}
1085pub type virtio_magma_connection_flush_resp_t = virtio_magma_connection_flush_resp;
1086#[repr(C, packed)]
1087#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1088pub struct virtio_magma_connection_get_notification_channel_handle_ctrl {
1089 pub hdr: virtio_magma_ctrl_hdr_t,
1090 pub connection: u64,
1091}
1092pub type virtio_magma_connection_get_notification_channel_handle_ctrl_t =
1093 virtio_magma_connection_get_notification_channel_handle_ctrl;
1094#[repr(C, packed)]
1095#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1096pub struct virtio_magma_connection_get_notification_channel_handle_resp {
1097 pub hdr: virtio_magma_ctrl_hdr_t,
1098 pub result_return: u32,
1099}
1100pub type virtio_magma_connection_get_notification_channel_handle_resp_t =
1101 virtio_magma_connection_get_notification_channel_handle_resp;
1102#[repr(C, packed)]
1103#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1104pub struct virtio_magma_connection_read_notification_channel_ctrl {
1105 pub hdr: virtio_magma_ctrl_hdr_t,
1106 pub connection: u64,
1107 pub buffer: u64,
1108 pub buffer_size: u64,
1109}
1110pub type virtio_magma_connection_read_notification_channel_ctrl_t =
1111 virtio_magma_connection_read_notification_channel_ctrl;
1112#[repr(C, packed)]
1113#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1114pub struct virtio_magma_connection_read_notification_channel_resp {
1115 pub hdr: virtio_magma_ctrl_hdr_t,
1116 pub buffer_size_out: u64,
1117 pub more_data_out: u64,
1118 pub result_return: u64,
1119}
1120pub type virtio_magma_connection_read_notification_channel_resp_t =
1121 virtio_magma_connection_read_notification_channel_resp;
1122#[repr(C, packed)]
1123#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1124pub struct virtio_magma_buffer_clean_cache_ctrl {
1125 pub hdr: virtio_magma_ctrl_hdr_t,
1126 pub buffer: u64,
1127 pub offset: u64,
1128 pub size: u64,
1129 pub operation: u64,
1130}
1131pub type virtio_magma_buffer_clean_cache_ctrl_t = virtio_magma_buffer_clean_cache_ctrl;
1132#[repr(C, packed)]
1133#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1134pub struct virtio_magma_buffer_clean_cache_resp {
1135 pub hdr: virtio_magma_ctrl_hdr_t,
1136 pub result_return: u64,
1137}
1138pub type virtio_magma_buffer_clean_cache_resp_t = virtio_magma_buffer_clean_cache_resp;
1139#[repr(C, packed)]
1140#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1141pub struct virtio_magma_buffer_set_cache_policy_ctrl {
1142 pub hdr: virtio_magma_ctrl_hdr_t,
1143 pub buffer: u64,
1144 pub policy: u64,
1145}
1146pub type virtio_magma_buffer_set_cache_policy_ctrl_t = virtio_magma_buffer_set_cache_policy_ctrl;
1147#[repr(C, packed)]
1148#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1149pub struct virtio_magma_buffer_set_cache_policy_resp {
1150 pub hdr: virtio_magma_ctrl_hdr_t,
1151 pub result_return: u64,
1152}
1153pub type virtio_magma_buffer_set_cache_policy_resp_t = virtio_magma_buffer_set_cache_policy_resp;
1154#[repr(C, packed)]
1155#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1156pub struct virtio_magma_buffer_get_cache_policy_ctrl {
1157 pub hdr: virtio_magma_ctrl_hdr_t,
1158 pub buffer: u64,
1159}
1160pub type virtio_magma_buffer_get_cache_policy_ctrl_t = virtio_magma_buffer_get_cache_policy_ctrl;
1161#[repr(C, packed)]
1162#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1163pub struct virtio_magma_buffer_get_cache_policy_resp {
1164 pub hdr: virtio_magma_ctrl_hdr_t,
1165 pub cache_policy_out: u64,
1166 pub result_return: u64,
1167}
1168pub type virtio_magma_buffer_get_cache_policy_resp_t = virtio_magma_buffer_get_cache_policy_resp;
1169#[repr(C, packed)]
1170#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1171pub struct virtio_magma_buffer_set_name_ctrl {
1172 pub hdr: virtio_magma_ctrl_hdr_t,
1173 pub buffer: u64,
1174 pub name: u64,
1175}
1176pub type virtio_magma_buffer_set_name_ctrl_t = virtio_magma_buffer_set_name_ctrl;
1177#[repr(C, packed)]
1178#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1179pub struct virtio_magma_buffer_set_name_resp {
1180 pub hdr: virtio_magma_ctrl_hdr_t,
1181 pub result_return: u64,
1182}
1183pub type virtio_magma_buffer_set_name_resp_t = virtio_magma_buffer_set_name_resp;
1184#[repr(C, packed)]
1185#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1186pub struct virtio_magma_buffer_get_info_ctrl {
1187 pub hdr: virtio_magma_ctrl_hdr_t,
1188 pub buffer: u64,
1189 pub info_out: u64,
1190}
1191pub type virtio_magma_buffer_get_info_ctrl_t = virtio_magma_buffer_get_info_ctrl;
1192#[repr(C, packed)]
1193#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1194pub struct virtio_magma_buffer_get_info_resp {
1195 pub hdr: virtio_magma_ctrl_hdr_t,
1196 pub result_return: u64,
1197}
1198pub type virtio_magma_buffer_get_info_resp_t = virtio_magma_buffer_get_info_resp;
1199#[repr(C, packed)]
1200#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1201pub struct virtio_magma_buffer_get_handle_ctrl {
1202 pub hdr: virtio_magma_ctrl_hdr_t,
1203 pub buffer: u64,
1204}
1205pub type virtio_magma_buffer_get_handle_ctrl_t = virtio_magma_buffer_get_handle_ctrl;
1206#[repr(C, packed)]
1207#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1208pub struct virtio_magma_buffer_get_handle_resp {
1209 pub hdr: virtio_magma_ctrl_hdr_t,
1210 pub handle_out: u64,
1211 pub result_return: u64,
1212}
1213pub type virtio_magma_buffer_get_handle_resp_t = virtio_magma_buffer_get_handle_resp;
1214#[repr(C, packed)]
1215#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1216pub struct virtio_magma_buffer_export_ctrl {
1217 pub hdr: virtio_magma_ctrl_hdr_t,
1218 pub buffer: u64,
1219}
1220pub type virtio_magma_buffer_export_ctrl_t = virtio_magma_buffer_export_ctrl;
1221#[repr(C, packed)]
1222#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1223pub struct virtio_magma_buffer_export_resp {
1224 pub hdr: virtio_magma_ctrl_hdr_t,
1225 pub buffer_handle_out: u64,
1226 pub result_return: u64,
1227}
1228pub type virtio_magma_buffer_export_resp_t = virtio_magma_buffer_export_resp;
1229#[repr(C, packed)]
1230#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1231pub struct virtio_magma_semaphore_signal_ctrl {
1232 pub hdr: virtio_magma_ctrl_hdr_t,
1233 pub semaphore: u64,
1234}
1235pub type virtio_magma_semaphore_signal_ctrl_t = virtio_magma_semaphore_signal_ctrl;
1236#[repr(C, packed)]
1237#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1238pub struct virtio_magma_semaphore_signal_resp {
1239 pub hdr: virtio_magma_ctrl_hdr_t,
1240}
1241pub type virtio_magma_semaphore_signal_resp_t = virtio_magma_semaphore_signal_resp;
1242#[repr(C, packed)]
1243#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1244pub struct virtio_magma_semaphore_reset_ctrl {
1245 pub hdr: virtio_magma_ctrl_hdr_t,
1246 pub semaphore: u64,
1247}
1248pub type virtio_magma_semaphore_reset_ctrl_t = virtio_magma_semaphore_reset_ctrl;
1249#[repr(C, packed)]
1250#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1251pub struct virtio_magma_semaphore_reset_resp {
1252 pub hdr: virtio_magma_ctrl_hdr_t,
1253}
1254pub type virtio_magma_semaphore_reset_resp_t = virtio_magma_semaphore_reset_resp;
1255#[repr(C, packed)]
1256#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1257pub struct virtio_magma_semaphore_export_ctrl {
1258 pub hdr: virtio_magma_ctrl_hdr_t,
1259 pub semaphore: u64,
1260}
1261pub type virtio_magma_semaphore_export_ctrl_t = virtio_magma_semaphore_export_ctrl;
1262#[repr(C, packed)]
1263#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1264pub struct virtio_magma_semaphore_export_resp {
1265 pub hdr: virtio_magma_ctrl_hdr_t,
1266 pub semaphore_handle_out: u64,
1267 pub result_return: u64,
1268}
1269pub type virtio_magma_semaphore_export_resp_t = virtio_magma_semaphore_export_resp;
1270#[repr(C, packed)]
1271#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1272pub struct virtio_magma_poll_ctrl {
1273 pub hdr: virtio_magma_ctrl_hdr_t,
1274 pub items: u64,
1275 pub count: u32,
1276 pub timeout_ns: u64,
1277}
1278pub type virtio_magma_poll_ctrl_t = virtio_magma_poll_ctrl;
1279#[repr(C, packed)]
1280#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1281pub struct virtio_magma_poll_resp {
1282 pub hdr: virtio_magma_ctrl_hdr_t,
1283 pub result_return: u64,
1284}
1285pub type virtio_magma_poll_resp_t = virtio_magma_poll_resp;
1286#[repr(C, packed)]
1287#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1288pub struct virtio_magma_initialize_tracing_ctrl {
1289 pub hdr: virtio_magma_ctrl_hdr_t,
1290 pub channel: u32,
1291}
1292pub type virtio_magma_initialize_tracing_ctrl_t = virtio_magma_initialize_tracing_ctrl;
1293#[repr(C, packed)]
1294#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1295pub struct virtio_magma_initialize_tracing_resp {
1296 pub hdr: virtio_magma_ctrl_hdr_t,
1297 pub result_return: u64,
1298}
1299pub type virtio_magma_initialize_tracing_resp_t = virtio_magma_initialize_tracing_resp;
1300#[repr(C, packed)]
1301#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1302pub struct virtio_magma_initialize_logging_ctrl {
1303 pub hdr: virtio_magma_ctrl_hdr_t,
1304 pub channel: u32,
1305}
1306pub type virtio_magma_initialize_logging_ctrl_t = virtio_magma_initialize_logging_ctrl;
1307#[repr(C, packed)]
1308#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1309pub struct virtio_magma_initialize_logging_resp {
1310 pub hdr: virtio_magma_ctrl_hdr_t,
1311 pub result_return: u64,
1312}
1313pub type virtio_magma_initialize_logging_resp_t = virtio_magma_initialize_logging_resp;
1314#[repr(C, packed)]
1315#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1316pub struct virtio_magma_connection_enable_performance_counter_access_ctrl {
1317 pub hdr: virtio_magma_ctrl_hdr_t,
1318 pub connection: u64,
1319 pub channel: u32,
1320}
1321pub type virtio_magma_connection_enable_performance_counter_access_ctrl_t =
1322 virtio_magma_connection_enable_performance_counter_access_ctrl;
1323#[repr(C, packed)]
1324#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1325pub struct virtio_magma_connection_enable_performance_counter_access_resp {
1326 pub hdr: virtio_magma_ctrl_hdr_t,
1327 pub result_return: u64,
1328}
1329pub type virtio_magma_connection_enable_performance_counter_access_resp_t =
1330 virtio_magma_connection_enable_performance_counter_access_resp;
1331#[repr(C, packed)]
1332#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1333pub struct virtio_magma_connection_enable_performance_counters_ctrl {
1334 pub hdr: virtio_magma_ctrl_hdr_t,
1335 pub connection: u64,
1336 pub counters: u64,
1337 pub counters_count: u64,
1338}
1339pub type virtio_magma_connection_enable_performance_counters_ctrl_t =
1340 virtio_magma_connection_enable_performance_counters_ctrl;
1341#[repr(C, packed)]
1342#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1343pub struct virtio_magma_connection_enable_performance_counters_resp {
1344 pub hdr: virtio_magma_ctrl_hdr_t,
1345 pub result_return: u64,
1346}
1347pub type virtio_magma_connection_enable_performance_counters_resp_t =
1348 virtio_magma_connection_enable_performance_counters_resp;
1349#[repr(C, packed)]
1350#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1351pub struct virtio_magma_connection_create_performance_counter_buffer_pool_ctrl {
1352 pub hdr: virtio_magma_ctrl_hdr_t,
1353 pub connection: u64,
1354}
1355pub type virtio_magma_connection_create_performance_counter_buffer_pool_ctrl_t =
1356 virtio_magma_connection_create_performance_counter_buffer_pool_ctrl;
1357#[repr(C, packed)]
1358#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1359pub struct virtio_magma_connection_create_performance_counter_buffer_pool_resp {
1360 pub hdr: virtio_magma_ctrl_hdr_t,
1361 pub pool_id_out: u64,
1362 pub notification_handle_out: u64,
1363 pub result_return: u64,
1364}
1365pub type virtio_magma_connection_create_performance_counter_buffer_pool_resp_t =
1366 virtio_magma_connection_create_performance_counter_buffer_pool_resp;
1367#[repr(C, packed)]
1368#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1369pub struct virtio_magma_connection_release_performance_counter_buffer_pool_ctrl {
1370 pub hdr: virtio_magma_ctrl_hdr_t,
1371 pub connection: u64,
1372 pub pool_id: u64,
1373}
1374pub type virtio_magma_connection_release_performance_counter_buffer_pool_ctrl_t =
1375 virtio_magma_connection_release_performance_counter_buffer_pool_ctrl;
1376#[repr(C, packed)]
1377#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1378pub struct virtio_magma_connection_release_performance_counter_buffer_pool_resp {
1379 pub hdr: virtio_magma_ctrl_hdr_t,
1380 pub result_return: u64,
1381}
1382pub type virtio_magma_connection_release_performance_counter_buffer_pool_resp_t =
1383 virtio_magma_connection_release_performance_counter_buffer_pool_resp;
1384#[repr(C, packed)]
1385#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1386pub struct virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_ctrl {
1387 pub hdr: virtio_magma_ctrl_hdr_t,
1388 pub connection: u64,
1389 pub pool_id: u64,
1390 pub offsets: u64,
1391 pub offsets_count: u64,
1392}
1393pub type virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_ctrl_t =
1394 virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_ctrl;
1395#[repr(C, packed)]
1396#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1397pub struct virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_resp {
1398 pub hdr: virtio_magma_ctrl_hdr_t,
1399 pub result_return: u64,
1400}
1401pub type virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_resp_t =
1402 virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_resp;
1403#[repr(C, packed)]
1404#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1405pub struct virtio_magma_connection_remove_performance_counter_buffer_from_pool_ctrl {
1406 pub hdr: virtio_magma_ctrl_hdr_t,
1407 pub connection: u64,
1408 pub pool_id: u64,
1409 pub buffer: u64,
1410}
1411pub type virtio_magma_connection_remove_performance_counter_buffer_from_pool_ctrl_t =
1412 virtio_magma_connection_remove_performance_counter_buffer_from_pool_ctrl;
1413#[repr(C, packed)]
1414#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1415pub struct virtio_magma_connection_remove_performance_counter_buffer_from_pool_resp {
1416 pub hdr: virtio_magma_ctrl_hdr_t,
1417 pub result_return: u64,
1418}
1419pub type virtio_magma_connection_remove_performance_counter_buffer_from_pool_resp_t =
1420 virtio_magma_connection_remove_performance_counter_buffer_from_pool_resp;
1421#[repr(C, packed)]
1422#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1423pub struct virtio_magma_connection_dump_performance_counters_ctrl {
1424 pub hdr: virtio_magma_ctrl_hdr_t,
1425 pub connection: u64,
1426 pub pool_id: u64,
1427 pub trigger_id: u32,
1428}
1429pub type virtio_magma_connection_dump_performance_counters_ctrl_t =
1430 virtio_magma_connection_dump_performance_counters_ctrl;
1431#[repr(C, packed)]
1432#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1433pub struct virtio_magma_connection_dump_performance_counters_resp {
1434 pub hdr: virtio_magma_ctrl_hdr_t,
1435 pub result_return: u64,
1436}
1437pub type virtio_magma_connection_dump_performance_counters_resp_t =
1438 virtio_magma_connection_dump_performance_counters_resp;
1439#[repr(C, packed)]
1440#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1441pub struct virtio_magma_connection_clear_performance_counters_ctrl {
1442 pub hdr: virtio_magma_ctrl_hdr_t,
1443 pub connection: u64,
1444 pub counters: u64,
1445 pub counters_count: u64,
1446}
1447pub type virtio_magma_connection_clear_performance_counters_ctrl_t =
1448 virtio_magma_connection_clear_performance_counters_ctrl;
1449#[repr(C, packed)]
1450#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1451pub struct virtio_magma_connection_clear_performance_counters_resp {
1452 pub hdr: virtio_magma_ctrl_hdr_t,
1453 pub result_return: u64,
1454}
1455pub type virtio_magma_connection_clear_performance_counters_resp_t =
1456 virtio_magma_connection_clear_performance_counters_resp;
1457#[repr(C, packed)]
1458#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1459pub struct virtio_magma_connection_read_performance_counter_completion_ctrl {
1460 pub hdr: virtio_magma_ctrl_hdr_t,
1461 pub connection: u64,
1462 pub pool_id: u64,
1463}
1464pub type virtio_magma_connection_read_performance_counter_completion_ctrl_t =
1465 virtio_magma_connection_read_performance_counter_completion_ctrl;
1466#[repr(C, packed)]
1467#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1468pub struct virtio_magma_connection_read_performance_counter_completion_resp {
1469 pub hdr: virtio_magma_ctrl_hdr_t,
1470 pub trigger_id_out: u64,
1471 pub buffer_id_out: u64,
1472 pub buffer_offset_out: u64,
1473 pub time_out: u64,
1474 pub result_flags_out: u64,
1475 pub result_return: u64,
1476}
1477pub type virtio_magma_connection_read_performance_counter_completion_resp_t =
1478 virtio_magma_connection_read_performance_counter_completion_resp;
1479#[repr(C, packed)]
1480#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1481pub struct virtio_magma_virt_connection_create_image_ctrl {
1482 pub hdr: virtio_magma_ctrl_hdr_t,
1483 pub connection: u64,
1484 pub create_info: u64,
1485}
1486pub type virtio_magma_virt_connection_create_image_ctrl_t =
1487 virtio_magma_virt_connection_create_image_ctrl;
1488#[repr(C, packed)]
1489#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1490pub struct virtio_magma_virt_connection_create_image_resp {
1491 pub hdr: virtio_magma_ctrl_hdr_t,
1492 pub size_out: u64,
1493 pub image_out: u64,
1494 pub buffer_id_out: u64,
1495 pub result_return: u64,
1496}
1497pub type virtio_magma_virt_connection_create_image_resp_t =
1498 virtio_magma_virt_connection_create_image_resp;
1499#[repr(C, packed)]
1500#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1501pub struct virtio_magma_virt_connection_get_image_info_ctrl {
1502 pub hdr: virtio_magma_ctrl_hdr_t,
1503 pub connection: u64,
1504 pub image: u64,
1505 pub image_info_out: u64,
1506}
1507pub type virtio_magma_virt_connection_get_image_info_ctrl_t =
1508 virtio_magma_virt_connection_get_image_info_ctrl;
1509#[repr(C, packed)]
1510#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1511pub struct virtio_magma_virt_connection_get_image_info_resp {
1512 pub hdr: virtio_magma_ctrl_hdr_t,
1513 pub result_return: u64,
1514}
1515pub type virtio_magma_virt_connection_get_image_info_resp_t =
1516 virtio_magma_virt_connection_get_image_info_resp;
1517#[repr(C, packed)]
1518#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1519pub struct virtio_magma_internal_release_handle_ctrl {
1520 pub hdr: virtio_magma_ctrl_hdr_t,
1521 pub handle: u32,
1522}
1523pub type virtio_magma_internal_release_handle_ctrl_t = virtio_magma_internal_release_handle_ctrl;
1524#[repr(C, packed)]
1525#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1526pub struct virtio_magma_internal_release_handle_resp {
1527 pub hdr: virtio_magma_ctrl_hdr_t,
1528 pub result_return: u64,
1529}
1530pub type virtio_magma_internal_release_handle_resp_t = virtio_magma_internal_release_handle_resp;
1531#[repr(C, packed)]
1532#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1533pub struct virtio_magma_internal_map_ctrl {
1534 pub hdr: virtio_magma_ctrl_hdr_t,
1535 pub buffer: u32,
1536 pub length: u64,
1537}
1538pub type virtio_magma_internal_map_ctrl_t = virtio_magma_internal_map_ctrl;
1539#[repr(C, packed)]
1540#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1541pub struct virtio_magma_internal_map_resp {
1542 pub hdr: virtio_magma_ctrl_hdr_t,
1543 pub address_out: u64,
1544 pub result_return: u64,
1545}
1546pub type virtio_magma_internal_map_resp_t = virtio_magma_internal_map_resp;
1547#[repr(C, packed)]
1548#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1549pub struct virtio_magma_internal_unmap_ctrl {
1550 pub hdr: virtio_magma_ctrl_hdr_t,
1551 pub buffer: u32,
1552 pub address: u64,
1553}
1554pub type virtio_magma_internal_unmap_ctrl_t = virtio_magma_internal_unmap_ctrl;
1555#[repr(C, packed)]
1556#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
1557pub struct virtio_magma_internal_unmap_resp {
1558 pub hdr: virtio_magma_ctrl_hdr_t,
1559 pub result_return: u64,
1560}
1561pub type virtio_magma_internal_unmap_resp_t = virtio_magma_internal_unmap_resp;
1562pub const MAGMA_STATUS_OK: magma_status_t = 0;
1563pub const MAGMA_STATUS_INTERNAL_ERROR: magma_status_t = -1;
1564pub const MAGMA_STATUS_INVALID_ARGS: magma_status_t = -2;
1565pub const MAGMA_STATUS_MEMORY_ERROR: magma_status_t = -4;
1566pub const MAGMA_STATUS_TIMED_OUT: magma_status_t = -7;
1567pub const MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE: u32 = 1;
1568pub const MAGMA_IMAGE_CREATE_FLAGS_VULKAN_USAGE: u32 = 2;
1569pub const MAGMA_MAX_IMAGE_PLANES: u32 = 4;
1570pub const MAGMA_COHERENCY_DOMAIN_CPU: magma_coherency_domain_t = 0;
1571pub const MAGMA_COHERENCY_DOMAIN_RAM: magma_coherency_domain_t = 1;
1572pub const MAGMA_COHERENCY_DOMAIN_INACCESSIBLE: magma_coherency_domain_t = 2;
1573pub const MAGMA_POLL_TYPE_SEMAPHORE: u32 = 1;
1574pub const MAGMA_POLL_TYPE_HANDLE: u32 = 2;
1575pub const MAGMA_POLL_CONDITION_SIGNALED: u32 = 3;
1576pub const MAGMA_CACHE_POLICY_CACHED: magma_cache_policy_t = 0;
1577pub const MAGMA_CACHE_POLICY_WRITE_COMBINING: magma_cache_policy_t = 1;
1578pub const MAGMA_CACHE_POLICY_UNCACHED: magma_cache_policy_t = 2;
1579pub const MAGMA_QUERY_VENDOR_ID: magma_query_t = 0;
1580pub const MAGMA_IMPORT_SEMAPHORE_ONE_SHOT: u64 = 1;