1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const EC_MAX_NUM_DEVICES: u32 = 1;
84pub const EC_MAX_SYNC_MANAGERS: u32 = 16;
85pub const EC_MAX_STRING_LENGTH: u32 = 64;
86pub const EC_MAX_PORTS: u32 = 4;
87pub const EC_MAX_SII_SIZE: u32 = 4096;
88pub const EC_MAX_FMMUS: u32 = 16;
89pub const EC_IOCTL_TYPE: u32 = 164;
90pub const EC_IOCTL_VERSION_MAGIC: u32 = 31;
91pub const EC_IOCTL_STRING_SIZE: u32 = 64;
92pub const EC_MAX_SDO_DATA_SIZE: u32 = 1024;
93pub const EC_MAX_IDN_DATA_SIZE: u32 = 1024;
94pub const EC_MAX_FLAG_KEY_SIZE: u32 = 128;
95#[doc = " Master state.\n\n This is used for the output parameter of ecrt_master_state().\n\n \\see ecrt_master_state()."]
96#[repr(C)]
97#[derive(Default, Copy, Clone)]
98pub struct ec_master_state_t {
99 #[doc = "< Sum of responding slaves on all\nEthernet devices."]
100 pub slaves_responding: ::std::os::raw::c_uint,
101 pub _bitfield_align_1: [u8; 0],
102 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
103 pub __bindgen_padding_0: [u8; 3usize],
104}
105impl ec_master_state_t {
106 #[inline]
107 pub fn al_states(&self) -> ::std::os::raw::c_uint {
108 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
109 }
110 #[inline]
111 pub fn set_al_states(&mut self, val: ::std::os::raw::c_uint) {
112 unsafe {
113 let val: u32 = ::std::mem::transmute(val);
114 self._bitfield_1.set(0usize, 4u8, val as u64)
115 }
116 }
117 #[inline]
118 pub fn link_up(&self) -> ::std::os::raw::c_uint {
119 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
120 }
121 #[inline]
122 pub fn set_link_up(&mut self, val: ::std::os::raw::c_uint) {
123 unsafe {
124 let val: u32 = ::std::mem::transmute(val);
125 self._bitfield_1.set(4usize, 1u8, val as u64)
126 }
127 }
128 #[inline]
129 pub fn new_bitfield_1(
130 al_states: ::std::os::raw::c_uint,
131 link_up: ::std::os::raw::c_uint,
132 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
133 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
134 __bindgen_bitfield_unit.set(0usize, 4u8, {
135 let al_states: u32 = unsafe { ::std::mem::transmute(al_states) };
136 al_states as u64
137 });
138 __bindgen_bitfield_unit.set(4usize, 1u8, {
139 let link_up: u32 = unsafe { ::std::mem::transmute(link_up) };
140 link_up as u64
141 });
142 __bindgen_bitfield_unit
143 }
144}
145#[doc = " Redundant link state.\n\n This is used for the output parameter of ecrt_master_link_state().\n\n \\see ecrt_master_link_state()."]
146#[repr(C)]
147#[derive(Default, Copy, Clone)]
148pub struct ec_master_link_state_t {
149 #[doc = "< Sum of responding slaves on the given\nlink."]
150 pub slaves_responding: ::std::os::raw::c_uint,
151 pub _bitfield_align_1: [u8; 0],
152 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
153 pub __bindgen_padding_0: [u8; 3usize],
154}
155impl ec_master_link_state_t {
156 #[inline]
157 pub fn al_states(&self) -> ::std::os::raw::c_uint {
158 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
159 }
160 #[inline]
161 pub fn set_al_states(&mut self, val: ::std::os::raw::c_uint) {
162 unsafe {
163 let val: u32 = ::std::mem::transmute(val);
164 self._bitfield_1.set(0usize, 4u8, val as u64)
165 }
166 }
167 #[inline]
168 pub fn link_up(&self) -> ::std::os::raw::c_uint {
169 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
170 }
171 #[inline]
172 pub fn set_link_up(&mut self, val: ::std::os::raw::c_uint) {
173 unsafe {
174 let val: u32 = ::std::mem::transmute(val);
175 self._bitfield_1.set(4usize, 1u8, val as u64)
176 }
177 }
178 #[inline]
179 pub fn new_bitfield_1(
180 al_states: ::std::os::raw::c_uint,
181 link_up: ::std::os::raw::c_uint,
182 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
183 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
184 __bindgen_bitfield_unit.set(0usize, 4u8, {
185 let al_states: u32 = unsafe { ::std::mem::transmute(al_states) };
186 al_states as u64
187 });
188 __bindgen_bitfield_unit.set(4usize, 1u8, {
189 let link_up: u32 = unsafe { ::std::mem::transmute(link_up) };
190 link_up as u64
191 });
192 __bindgen_bitfield_unit
193 }
194}
195#[doc = " Slave configuration state.\n\n This is used as an output parameter of ecrt_slave_config_state().\n\n \\see ecrt_slave_config_state()."]
196#[repr(C)]
197#[repr(align(4))]
198#[derive(Default, Copy, Clone)]
199pub struct ec_slave_config_state_t {
200 pub _bitfield_align_1: [u8; 0],
201 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
202 pub __bindgen_padding_0: [u8; 3usize],
203}
204impl ec_slave_config_state_t {
205 #[inline]
206 pub fn online(&self) -> ::std::os::raw::c_uint {
207 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
208 }
209 #[inline]
210 pub fn set_online(&mut self, val: ::std::os::raw::c_uint) {
211 unsafe {
212 let val: u32 = ::std::mem::transmute(val);
213 self._bitfield_1.set(0usize, 1u8, val as u64)
214 }
215 }
216 #[inline]
217 pub fn operational(&self) -> ::std::os::raw::c_uint {
218 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
219 }
220 #[inline]
221 pub fn set_operational(&mut self, val: ::std::os::raw::c_uint) {
222 unsafe {
223 let val: u32 = ::std::mem::transmute(val);
224 self._bitfield_1.set(1usize, 1u8, val as u64)
225 }
226 }
227 #[inline]
228 pub fn al_state(&self) -> ::std::os::raw::c_uint {
229 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u32) }
230 }
231 #[inline]
232 pub fn set_al_state(&mut self, val: ::std::os::raw::c_uint) {
233 unsafe {
234 let val: u32 = ::std::mem::transmute(val);
235 self._bitfield_1.set(2usize, 4u8, val as u64)
236 }
237 }
238 #[inline]
239 pub fn new_bitfield_1(
240 online: ::std::os::raw::c_uint,
241 operational: ::std::os::raw::c_uint,
242 al_state: ::std::os::raw::c_uint,
243 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
244 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
245 __bindgen_bitfield_unit.set(0usize, 1u8, {
246 let online: u32 = unsafe { ::std::mem::transmute(online) };
247 online as u64
248 });
249 __bindgen_bitfield_unit.set(1usize, 1u8, {
250 let operational: u32 = unsafe { ::std::mem::transmute(operational) };
251 operational as u64
252 });
253 __bindgen_bitfield_unit.set(2usize, 4u8, {
254 let al_state: u32 = unsafe { ::std::mem::transmute(al_state) };
255 al_state as u64
256 });
257 __bindgen_bitfield_unit
258 }
259}
260#[doc = "< Port is not implemented."]
261pub const EC_PORT_NOT_IMPLEMENTED: ec_slave_port_desc_t = 0;
262#[doc = "< Port is not configured."]
263pub const EC_PORT_NOT_CONFIGURED: ec_slave_port_desc_t = 1;
264#[doc = "< Port is an E-Bus."]
265pub const EC_PORT_EBUS: ec_slave_port_desc_t = 2;
266#[doc = "< Port is a MII."]
267pub const EC_PORT_MII: ec_slave_port_desc_t = 3;
268#[doc = " EtherCAT slave port descriptor."]
269pub type ec_slave_port_desc_t = ::std::os::raw::c_uint;
270#[doc = " EtherCAT slave port information."]
271#[repr(C)]
272#[derive(Default, Copy, Clone)]
273pub struct ec_slave_port_link_t {
274 #[doc = "< Link detected."]
275 pub link_up: u8,
276 #[doc = "< Loop closed."]
277 pub loop_closed: u8,
278 #[doc = "< Detected signal on RX port."]
279 pub signal_detected: u8,
280}
281#[doc = "< No registered process data were exchanged."]
282pub const EC_WC_ZERO: ec_wc_state_t = 0;
283#[doc = "< Some of the registered process data were\nexchanged."]
284pub const EC_WC_INCOMPLETE: ec_wc_state_t = 1;
285#[doc = "< All registered process data were exchanged."]
286pub const EC_WC_COMPLETE: ec_wc_state_t = 2;
287#[doc = " Domain working counter interpretation.\n\n This is used in ec_domain_state_t."]
288pub type ec_wc_state_t = ::std::os::raw::c_uint;
289#[doc = " Domain state.\n\n This is used for the output parameter of ecrt_domain_state()."]
290#[repr(C)]
291#[derive(Copy, Clone)]
292pub struct ec_domain_state_t {
293 #[doc = "< Value of the last working counter."]
294 pub working_counter: ::std::os::raw::c_uint,
295 #[doc = "< Working counter interpretation."]
296 pub wc_state: ec_wc_state_t,
297 #[doc = "< Redundant link is in use."]
298 pub redundancy_active: ::std::os::raw::c_uint,
299}
300impl Default for ec_domain_state_t {
301 fn default() -> Self {
302 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
303 unsafe {
304 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
305 s.assume_init()
306 }
307 }
308}
309#[doc = "< Invalid direction. Do not use this value."]
310pub const EC_DIR_INVALID: ec_direction_t = 0;
311#[doc = "< Values written by the master."]
312pub const EC_DIR_OUTPUT: ec_direction_t = 1;
313#[doc = "< Values read by the master."]
314pub const EC_DIR_INPUT: ec_direction_t = 2;
315#[doc = "< Number of directions. For internal use only."]
316pub const EC_DIR_COUNT: ec_direction_t = 3;
317#[doc = " Direction type for PDO assignment functions."]
318pub type ec_direction_t = ::std::os::raw::c_uint;
319#[doc = "< Use the default setting of the sync manager."]
320pub const EC_WD_DEFAULT: ec_watchdog_mode_t = 0;
321#[doc = "< Enable the watchdog."]
322pub const EC_WD_ENABLE: ec_watchdog_mode_t = 1;
323#[doc = "< Disable the watchdog."]
324pub const EC_WD_DISABLE: ec_watchdog_mode_t = 2;
325#[doc = " Watchdog mode for sync manager configuration.\n\n Used to specify, if a sync manager's watchdog is to be enabled."]
326pub type ec_watchdog_mode_t = ::std::os::raw::c_uint;
327#[doc = "< Not requested."]
328pub const EC_REQUEST_UNUSED: ec_request_state_t = 0;
329#[doc = "< Request is being processed."]
330pub const EC_REQUEST_BUSY: ec_request_state_t = 1;
331#[doc = "< Request was processed successfully."]
332pub const EC_REQUEST_SUCCESS: ec_request_state_t = 2;
333#[doc = "< Request processing failed."]
334pub const EC_REQUEST_ERROR: ec_request_state_t = 3;
335#[doc = " Request state.\n\n This is used as return type for ecrt_sdo_request_state() and\n ecrt_voe_handler_state()."]
336pub type ec_request_state_t = ::std::os::raw::c_uint;
337#[doc = "< Init."]
338pub const EC_AL_STATE_INIT: ec_al_state_t = 1;
339#[doc = "< Pre-operational."]
340pub const EC_AL_STATE_PREOP: ec_al_state_t = 2;
341#[doc = "< Safe-operational."]
342pub const EC_AL_STATE_SAFEOP: ec_al_state_t = 4;
343#[doc = "< Operational."]
344pub const EC_AL_STATE_OP: ec_al_state_t = 8;
345#[doc = " Application-layer state."]
346pub type ec_al_state_t = ::std::os::raw::c_uint;
347#[doc = " Slave information interface CANopen over EtherCAT details flags."]
348#[repr(C, packed)]
349#[derive(Default, Copy, Clone)]
350pub struct ec_sii_coe_details_t {
351 pub _bitfield_align_1: [u8; 0],
352 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
353}
354impl ec_sii_coe_details_t {
355 #[inline]
356 pub fn enable_sdo(&self) -> u8 {
357 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
358 }
359 #[inline]
360 pub fn set_enable_sdo(&mut self, val: u8) {
361 unsafe {
362 let val: u8 = ::std::mem::transmute(val);
363 self._bitfield_1.set(0usize, 1u8, val as u64)
364 }
365 }
366 #[inline]
367 pub fn enable_sdo_info(&self) -> u8 {
368 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
369 }
370 #[inline]
371 pub fn set_enable_sdo_info(&mut self, val: u8) {
372 unsafe {
373 let val: u8 = ::std::mem::transmute(val);
374 self._bitfield_1.set(1usize, 1u8, val as u64)
375 }
376 }
377 #[inline]
378 pub fn enable_pdo_assign(&self) -> u8 {
379 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
380 }
381 #[inline]
382 pub fn set_enable_pdo_assign(&mut self, val: u8) {
383 unsafe {
384 let val: u8 = ::std::mem::transmute(val);
385 self._bitfield_1.set(2usize, 1u8, val as u64)
386 }
387 }
388 #[inline]
389 pub fn enable_pdo_configuration(&self) -> u8 {
390 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
391 }
392 #[inline]
393 pub fn set_enable_pdo_configuration(&mut self, val: u8) {
394 unsafe {
395 let val: u8 = ::std::mem::transmute(val);
396 self._bitfield_1.set(3usize, 1u8, val as u64)
397 }
398 }
399 #[inline]
400 pub fn enable_upload_at_startup(&self) -> u8 {
401 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
402 }
403 #[inline]
404 pub fn set_enable_upload_at_startup(&mut self, val: u8) {
405 unsafe {
406 let val: u8 = ::std::mem::transmute(val);
407 self._bitfield_1.set(4usize, 1u8, val as u64)
408 }
409 }
410 #[inline]
411 pub fn enable_sdo_complete_access(&self) -> u8 {
412 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
413 }
414 #[inline]
415 pub fn set_enable_sdo_complete_access(&mut self, val: u8) {
416 unsafe {
417 let val: u8 = ::std::mem::transmute(val);
418 self._bitfield_1.set(5usize, 1u8, val as u64)
419 }
420 }
421 #[inline]
422 pub fn new_bitfield_1(
423 enable_sdo: u8,
424 enable_sdo_info: u8,
425 enable_pdo_assign: u8,
426 enable_pdo_configuration: u8,
427 enable_upload_at_startup: u8,
428 enable_sdo_complete_access: u8,
429 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
430 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
431 __bindgen_bitfield_unit.set(0usize, 1u8, {
432 let enable_sdo: u8 = unsafe { ::std::mem::transmute(enable_sdo) };
433 enable_sdo as u64
434 });
435 __bindgen_bitfield_unit.set(1usize, 1u8, {
436 let enable_sdo_info: u8 = unsafe { ::std::mem::transmute(enable_sdo_info) };
437 enable_sdo_info as u64
438 });
439 __bindgen_bitfield_unit.set(2usize, 1u8, {
440 let enable_pdo_assign: u8 = unsafe { ::std::mem::transmute(enable_pdo_assign) };
441 enable_pdo_assign as u64
442 });
443 __bindgen_bitfield_unit.set(3usize, 1u8, {
444 let enable_pdo_configuration: u8 =
445 unsafe { ::std::mem::transmute(enable_pdo_configuration) };
446 enable_pdo_configuration as u64
447 });
448 __bindgen_bitfield_unit.set(4usize, 1u8, {
449 let enable_upload_at_startup: u8 =
450 unsafe { ::std::mem::transmute(enable_upload_at_startup) };
451 enable_upload_at_startup as u64
452 });
453 __bindgen_bitfield_unit.set(5usize, 1u8, {
454 let enable_sdo_complete_access: u8 =
455 unsafe { ::std::mem::transmute(enable_sdo_complete_access) };
456 enable_sdo_complete_access as u64
457 });
458 __bindgen_bitfield_unit
459 }
460}
461#[doc = " Slave information interface general flags."]
462#[repr(C, packed)]
463#[derive(Default, Copy, Clone)]
464pub struct ec_sii_general_flags_t {
465 pub _bitfield_align_1: [u8; 0],
466 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
467}
468impl ec_sii_general_flags_t {
469 #[inline]
470 pub fn enable_safeop(&self) -> u8 {
471 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
472 }
473 #[inline]
474 pub fn set_enable_safeop(&mut self, val: u8) {
475 unsafe {
476 let val: u8 = ::std::mem::transmute(val);
477 self._bitfield_1.set(0usize, 1u8, val as u64)
478 }
479 }
480 #[inline]
481 pub fn enable_not_lrw(&self) -> u8 {
482 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
483 }
484 #[inline]
485 pub fn set_enable_not_lrw(&mut self, val: u8) {
486 unsafe {
487 let val: u8 = ::std::mem::transmute(val);
488 self._bitfield_1.set(1usize, 1u8, val as u64)
489 }
490 }
491 #[inline]
492 pub fn new_bitfield_1(
493 enable_safeop: u8,
494 enable_not_lrw: u8,
495 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
496 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
497 __bindgen_bitfield_unit.set(0usize, 1u8, {
498 let enable_safeop: u8 = unsafe { ::std::mem::transmute(enable_safeop) };
499 enable_safeop as u64
500 });
501 __bindgen_bitfield_unit.set(1usize, 1u8, {
502 let enable_not_lrw: u8 = unsafe { ::std::mem::transmute(enable_not_lrw) };
503 enable_not_lrw as u64
504 });
505 __bindgen_bitfield_unit
506 }
507}
508#[doc = "< 32 bit."]
509pub const EC_DC_32: ec_slave_dc_range_t = 0;
510pub const EC_DC_64: ec_slave_dc_range_t = 1;
511#[doc = " EtherCAT slave distributed clocks range."]
512pub type ec_slave_dc_range_t = ::std::os::raw::c_uint;
513#[doc = " EtherCAT slave sync signal configuration."]
514#[repr(C)]
515#[derive(Default, Copy, Clone)]
516pub struct ec_sync_signal_t {
517 #[doc = "< Cycle time [ns]."]
518 pub cycle_time: u32,
519 #[doc = "< Shift time [ns]."]
520 pub shift_time: i32,
521}
522#[repr(C)]
523#[derive(Default, Copy, Clone)]
524pub struct ec_ioctl_module_t {
525 pub ioctl_version_magic: u32,
526 pub master_count: u32,
527}
528#[repr(C)]
529#[derive(Default, Copy, Clone)]
530pub struct ec_ioctl_master_t {
531 pub slave_count: u32,
532 pub config_count: u32,
533 pub domain_count: u32,
534 pub eoe_handler_count: u32,
535 pub phase: u8,
536 pub active: u8,
537 pub scan_busy: u8,
538 pub devices: [ec_ioctl_master_t_ec_ioctl_device; 1usize],
539 pub num_devices: u32,
540 pub tx_count: u64,
541 pub rx_count: u64,
542 pub tx_bytes: u64,
543 pub rx_bytes: u64,
544 pub tx_frame_rates: [i32; 3usize],
545 pub rx_frame_rates: [i32; 3usize],
546 pub tx_byte_rates: [i32; 3usize],
547 pub rx_byte_rates: [i32; 3usize],
548 pub loss_rates: [i32; 3usize],
549 pub app_time: u64,
550 pub dc_ref_time: u64,
551 pub ref_clock: u16,
552}
553#[repr(C)]
554#[derive(Default, Copy, Clone)]
555pub struct ec_ioctl_master_t_ec_ioctl_device {
556 pub address: [u8; 6usize],
557 pub attached: u8,
558 pub link_state: u8,
559 pub tx_count: u64,
560 pub rx_count: u64,
561 pub tx_bytes: u64,
562 pub rx_bytes: u64,
563 pub tx_errors: u64,
564 pub tx_frame_rates: [i32; 3usize],
565 pub rx_frame_rates: [i32; 3usize],
566 pub tx_byte_rates: [i32; 3usize],
567 pub rx_byte_rates: [i32; 3usize],
568}
569#[repr(C)]
570#[derive(Copy, Clone)]
571pub struct ec_ioctl_slave_t {
572 pub position: u16,
573 pub device_index: ::std::os::raw::c_uint,
574 pub vendor_id: u32,
575 pub product_code: u32,
576 pub revision_number: u32,
577 pub serial_number: u32,
578 pub alias: u16,
579 pub boot_rx_mailbox_offset: u16,
580 pub boot_rx_mailbox_size: u16,
581 pub boot_tx_mailbox_offset: u16,
582 pub boot_tx_mailbox_size: u16,
583 pub std_rx_mailbox_offset: u16,
584 pub std_rx_mailbox_size: u16,
585 pub std_tx_mailbox_offset: u16,
586 pub std_tx_mailbox_size: u16,
587 pub mailbox_protocols: u16,
588 pub has_general_category: u8,
589 pub coe_details: ec_sii_coe_details_t,
590 pub general_flags: ec_sii_general_flags_t,
591 pub current_on_ebus: i16,
592 pub ports: [ec_ioctl_slave_t__bindgen_ty_1; 4usize],
593 pub fmmu_bit: u8,
594 pub dc_supported: u8,
595 pub dc_range: ec_slave_dc_range_t,
596 pub has_dc_system_time: u8,
597 pub transmission_delay: u32,
598 pub al_state: u8,
599 pub error_flag: u8,
600 pub sync_count: u8,
601 pub sdo_count: u16,
602 pub sii_nwords: u32,
603 pub group: [::std::os::raw::c_char; 64usize],
604 pub image: [::std::os::raw::c_char; 64usize],
605 pub order: [::std::os::raw::c_char; 64usize],
606 pub name: [::std::os::raw::c_char; 64usize],
607}
608#[repr(C)]
609#[derive(Copy, Clone)]
610pub struct ec_ioctl_slave_t__bindgen_ty_1 {
611 pub desc: ec_slave_port_desc_t,
612 pub link: ec_slave_port_link_t,
613 pub receive_time: u32,
614 pub next_slave: u16,
615 pub delay_to_next_dc: u32,
616}
617impl Default for ec_ioctl_slave_t__bindgen_ty_1 {
618 fn default() -> Self {
619 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
620 unsafe {
621 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
622 s.assume_init()
623 }
624 }
625}
626impl Default for ec_ioctl_slave_t {
627 fn default() -> Self {
628 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
629 unsafe {
630 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
631 s.assume_init()
632 }
633 }
634}
635#[repr(C)]
636#[derive(Default, Copy, Clone)]
637pub struct ec_ioctl_slave_sync_t {
638 pub slave_position: u16,
639 pub sync_index: u32,
640 pub physical_start_address: u16,
641 pub default_size: u16,
642 pub control_register: u8,
643 pub enable: u8,
644 pub pdo_count: u8,
645}
646#[repr(C)]
647#[derive(Copy, Clone)]
648pub struct ec_ioctl_slave_sync_pdo_t {
649 pub slave_position: u16,
650 pub sync_index: u32,
651 pub pdo_pos: u32,
652 pub index: u16,
653 pub entry_count: u8,
654 pub name: [i8; 64usize],
655}
656impl Default for ec_ioctl_slave_sync_pdo_t {
657 fn default() -> Self {
658 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
659 unsafe {
660 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
661 s.assume_init()
662 }
663 }
664}
665#[repr(C)]
666#[derive(Copy, Clone)]
667pub struct ec_ioctl_slave_sync_pdo_entry_t {
668 pub slave_position: u16,
669 pub sync_index: u32,
670 pub pdo_pos: u32,
671 pub entry_pos: u32,
672 pub index: u16,
673 pub subindex: u8,
674 pub bit_length: u8,
675 pub name: [i8; 64usize],
676}
677impl Default for ec_ioctl_slave_sync_pdo_entry_t {
678 fn default() -> Self {
679 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
680 unsafe {
681 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
682 s.assume_init()
683 }
684 }
685}
686#[repr(C)]
687#[derive(Default, Copy, Clone)]
688pub struct ec_ioctl_domain_t {
689 pub index: u32,
690 pub data_size: u32,
691 pub logical_base_address: u32,
692 pub working_counter: [u16; 1usize],
693 pub expected_working_counter: u16,
694 pub fmmu_count: u32,
695}
696#[repr(C)]
697#[derive(Copy, Clone)]
698pub struct ec_ioctl_domain_fmmu_t {
699 pub domain_index: u32,
700 pub fmmu_index: u32,
701 pub slave_config_alias: u16,
702 pub slave_config_position: u16,
703 pub sync_index: u8,
704 pub dir: ec_direction_t,
705 pub logical_address: u32,
706 pub data_size: u32,
707}
708impl Default for ec_ioctl_domain_fmmu_t {
709 fn default() -> Self {
710 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
711 unsafe {
712 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
713 s.assume_init()
714 }
715 }
716}
717#[repr(C)]
718#[derive(Copy, Clone)]
719pub struct ec_ioctl_domain_data_t {
720 pub domain_index: u32,
721 pub data_size: u32,
722 pub target: *mut u8,
723}
724impl Default for ec_ioctl_domain_data_t {
725 fn default() -> Self {
726 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
727 unsafe {
728 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
729 s.assume_init()
730 }
731 }
732}
733#[repr(C)]
734#[derive(Default, Copy, Clone)]
735pub struct ec_ioctl_slave_state_t {
736 pub slave_position: u16,
737 pub al_state: u8,
738}
739#[repr(C)]
740#[derive(Copy, Clone)]
741pub struct ec_ioctl_slave_sdo_t {
742 pub slave_position: u16,
743 pub sdo_position: u16,
744 pub sdo_index: u16,
745 pub max_subindex: u8,
746 pub name: [i8; 64usize],
747}
748impl Default for ec_ioctl_slave_sdo_t {
749 fn default() -> Self {
750 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
751 unsafe {
752 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
753 s.assume_init()
754 }
755 }
756}
757#[repr(C)]
758#[derive(Copy, Clone)]
759pub struct ec_ioctl_slave_sdo_entry_t {
760 pub slave_position: u16,
761 pub sdo_spec: ::std::os::raw::c_int,
762 pub sdo_entry_subindex: u8,
763 pub data_type: u16,
764 pub bit_length: u16,
765 pub read_access: [u8; 3usize],
766 pub write_access: [u8; 3usize],
767 pub description: [i8; 64usize],
768}
769impl Default for ec_ioctl_slave_sdo_entry_t {
770 fn default() -> Self {
771 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
772 unsafe {
773 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
774 s.assume_init()
775 }
776 }
777}
778#[repr(C)]
779#[derive(Copy, Clone)]
780pub struct ec_ioctl_slave_sdo_upload_t {
781 pub slave_position: u16,
782 pub sdo_index: u16,
783 pub sdo_entry_subindex: u8,
784 pub target_size: usize,
785 pub target: *mut u8,
786 pub data_size: usize,
787 pub abort_code: u32,
788}
789impl Default for ec_ioctl_slave_sdo_upload_t {
790 fn default() -> Self {
791 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
792 unsafe {
793 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
794 s.assume_init()
795 }
796 }
797}
798#[repr(C)]
799#[derive(Copy, Clone)]
800pub struct ec_ioctl_slave_sdo_download_t {
801 pub slave_position: u16,
802 pub sdo_index: u16,
803 pub sdo_entry_subindex: u8,
804 pub complete_access: u8,
805 pub data_size: usize,
806 pub data: *mut u8,
807 pub abort_code: u32,
808}
809impl Default for ec_ioctl_slave_sdo_download_t {
810 fn default() -> Self {
811 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
812 unsafe {
813 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
814 s.assume_init()
815 }
816 }
817}
818#[repr(C)]
819#[derive(Copy, Clone)]
820pub struct ec_ioctl_slave_sii_t {
821 pub slave_position: u16,
822 pub offset: u16,
823 pub nwords: u32,
824 pub words: *mut u16,
825}
826impl Default for ec_ioctl_slave_sii_t {
827 fn default() -> Self {
828 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
829 unsafe {
830 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
831 s.assume_init()
832 }
833 }
834}
835#[repr(C)]
836#[derive(Copy, Clone)]
837pub struct ec_ioctl_slave_reg_t {
838 pub slave_position: u16,
839 pub emergency: u8,
840 pub address: u16,
841 pub size: usize,
842 pub data: *mut u8,
843}
844impl Default for ec_ioctl_slave_reg_t {
845 fn default() -> Self {
846 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
847 unsafe {
848 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
849 s.assume_init()
850 }
851 }
852}
853#[repr(C)]
854#[derive(Copy, Clone)]
855pub struct ec_ioctl_slave_foe_t {
856 pub slave_position: u16,
857 pub offset: u16,
858 pub buffer_size: usize,
859 pub buffer: *mut u8,
860 pub data_size: usize,
861 pub result: u32,
862 pub error_code: u32,
863 pub file_name: [::std::os::raw::c_char; 32usize],
864}
865impl Default for ec_ioctl_slave_foe_t {
866 fn default() -> Self {
867 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
868 unsafe {
869 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
870 s.assume_init()
871 }
872 }
873}
874#[repr(C)]
875#[derive(Copy, Clone)]
876pub struct ec_ioctl_slave_soe_read_t {
877 pub slave_position: u16,
878 pub drive_no: u8,
879 pub idn: u16,
880 pub mem_size: usize,
881 pub data: *mut u8,
882 pub data_size: usize,
883 pub error_code: u16,
884}
885impl Default for ec_ioctl_slave_soe_read_t {
886 fn default() -> Self {
887 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
888 unsafe {
889 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
890 s.assume_init()
891 }
892 }
893}
894#[repr(C)]
895#[derive(Copy, Clone)]
896pub struct ec_ioctl_slave_soe_write_t {
897 pub slave_position: u16,
898 pub drive_no: u8,
899 pub idn: u16,
900 pub data_size: usize,
901 pub data: *mut u8,
902 pub error_code: u16,
903}
904impl Default for ec_ioctl_slave_soe_write_t {
905 fn default() -> Self {
906 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
907 unsafe {
908 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
909 s.assume_init()
910 }
911 }
912}
913#[repr(C)]
914#[derive(Copy, Clone)]
915pub struct ec_ioctl_config_t {
916 pub config_index: u32,
917 pub alias: u16,
918 pub position: u16,
919 pub vendor_id: u32,
920 pub product_code: u32,
921 pub syncs: [ec_ioctl_config_t__bindgen_ty_1; 16usize],
922 pub watchdog_divider: u16,
923 pub watchdog_intervals: u16,
924 pub sdo_count: u32,
925 pub idn_count: u32,
926 pub flag_count: u32,
927 pub slave_position: i32,
928 pub dc_assign_activate: u16,
929 pub dc_sync: [ec_sync_signal_t; 2usize],
930}
931#[repr(C)]
932#[derive(Copy, Clone)]
933pub struct ec_ioctl_config_t__bindgen_ty_1 {
934 pub dir: ec_direction_t,
935 pub watchdog_mode: ec_watchdog_mode_t,
936 pub pdo_count: u32,
937 pub config_this: u8,
938}
939impl Default for ec_ioctl_config_t__bindgen_ty_1 {
940 fn default() -> Self {
941 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
942 unsafe {
943 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
944 s.assume_init()
945 }
946 }
947}
948impl Default for ec_ioctl_config_t {
949 fn default() -> Self {
950 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
951 unsafe {
952 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
953 s.assume_init()
954 }
955 }
956}
957#[repr(C)]
958#[derive(Copy, Clone)]
959pub struct ec_ioctl_config_pdo_t {
960 pub config_index: u32,
961 pub sync_index: u8,
962 pub pdo_pos: u16,
963 pub index: u16,
964 pub entry_count: u8,
965 pub name: [i8; 64usize],
966}
967impl Default for ec_ioctl_config_pdo_t {
968 fn default() -> Self {
969 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
970 unsafe {
971 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
972 s.assume_init()
973 }
974 }
975}
976#[repr(C)]
977#[derive(Copy, Clone)]
978pub struct ec_ioctl_config_pdo_entry_t {
979 pub config_index: u32,
980 pub sync_index: u8,
981 pub pdo_pos: u16,
982 pub entry_pos: u8,
983 pub index: u16,
984 pub subindex: u8,
985 pub bit_length: u8,
986 pub name: [i8; 64usize],
987}
988impl Default for ec_ioctl_config_pdo_entry_t {
989 fn default() -> Self {
990 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
991 unsafe {
992 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
993 s.assume_init()
994 }
995 }
996}
997#[repr(C)]
998#[derive(Copy, Clone)]
999pub struct ec_ioctl_config_sdo_t {
1000 pub config_index: u32,
1001 pub sdo_pos: u32,
1002 pub index: u16,
1003 pub subindex: u8,
1004 pub size: usize,
1005 pub data: [u8; 1024usize],
1006 pub complete_access: u8,
1007}
1008impl Default for ec_ioctl_config_sdo_t {
1009 fn default() -> Self {
1010 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1011 unsafe {
1012 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1013 s.assume_init()
1014 }
1015 }
1016}
1017#[repr(C)]
1018#[derive(Copy, Clone)]
1019pub struct ec_ioctl_config_idn_t {
1020 pub config_index: u32,
1021 pub idn_pos: u32,
1022 pub drive_no: u8,
1023 pub idn: u16,
1024 pub state: ec_al_state_t,
1025 pub size: usize,
1026 pub data: [u8; 1024usize],
1027}
1028impl Default for ec_ioctl_config_idn_t {
1029 fn default() -> Self {
1030 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1031 unsafe {
1032 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1033 s.assume_init()
1034 }
1035 }
1036}
1037#[repr(C)]
1038#[derive(Copy, Clone)]
1039pub struct ec_ioctl_config_flag_t {
1040 pub config_index: u32,
1041 pub flag_pos: u32,
1042 pub key: [::std::os::raw::c_char; 128usize],
1043 pub value: i32,
1044}
1045impl Default for ec_ioctl_config_flag_t {
1046 fn default() -> Self {
1047 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1048 unsafe {
1049 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1050 s.assume_init()
1051 }
1052 }
1053}
1054#[repr(C)]
1055#[derive(Default, Copy, Clone)]
1056pub struct ec_ioctl_eoe_handler_t {
1057 pub eoe_index: u16,
1058 pub name: [::std::os::raw::c_char; 20usize],
1059 pub slave_position: u16,
1060 pub open: u8,
1061 pub rx_bytes: u32,
1062 pub rx_rate: u32,
1063 pub tx_bytes: u32,
1064 pub tx_rate: u32,
1065 pub tx_queued_frames: u32,
1066 pub tx_queue_size: u32,
1067}
1068#[repr(C)]
1069#[derive(Copy, Clone)]
1070pub struct ec_ioctl_master_activate_t {
1071 pub process_data: *mut ::std::os::raw::c_void,
1072 pub process_data_size: usize,
1073}
1074impl Default for ec_ioctl_master_activate_t {
1075 fn default() -> Self {
1076 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1077 unsafe {
1078 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1079 s.assume_init()
1080 }
1081 }
1082}
1083#[repr(C)]
1084#[derive(Default, Copy, Clone)]
1085pub struct ec_ioctl_add_pdo_entry_t {
1086 pub config_index: u32,
1087 pub pdo_index: u16,
1088 pub entry_index: u16,
1089 pub entry_subindex: u8,
1090 pub entry_bit_length: u8,
1091}
1092#[repr(C)]
1093#[derive(Default, Copy, Clone)]
1094pub struct ec_ioctl_reg_pdo_entry_t {
1095 pub config_index: u32,
1096 pub entry_index: u16,
1097 pub entry_subindex: u8,
1098 pub domain_index: u32,
1099 pub bit_position: ::std::os::raw::c_uint,
1100}
1101#[repr(C)]
1102#[derive(Default, Copy, Clone)]
1103pub struct ec_ioctl_reg_pdo_pos_t {
1104 pub config_index: u32,
1105 pub sync_index: u32,
1106 pub pdo_pos: u32,
1107 pub entry_pos: u32,
1108 pub domain_index: u32,
1109 pub bit_position: ::std::os::raw::c_uint,
1110}
1111#[repr(C)]
1112#[derive(Copy, Clone)]
1113pub struct ec_ioctl_sc_sdo_t {
1114 pub config_index: u32,
1115 pub index: u16,
1116 pub subindex: u8,
1117 pub data: *const u8,
1118 pub size: usize,
1119 pub complete_access: u8,
1120}
1121impl Default for ec_ioctl_sc_sdo_t {
1122 fn default() -> Self {
1123 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1124 unsafe {
1125 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1126 s.assume_init()
1127 }
1128 }
1129}
1130#[repr(C)]
1131#[derive(Copy, Clone)]
1132pub struct ec_ioctl_sc_emerg_t {
1133 pub config_index: u32,
1134 pub size: usize,
1135 pub target: *mut u8,
1136 pub overruns: i32,
1137}
1138impl Default for ec_ioctl_sc_emerg_t {
1139 fn default() -> Self {
1140 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1141 unsafe {
1142 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1143 s.assume_init()
1144 }
1145 }
1146}
1147#[repr(C)]
1148#[derive(Copy, Clone)]
1149pub struct ec_ioctl_sc_state_t {
1150 pub config_index: u32,
1151 pub state: *mut ec_slave_config_state_t,
1152}
1153impl Default for ec_ioctl_sc_state_t {
1154 fn default() -> Self {
1155 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1156 unsafe {
1157 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1158 s.assume_init()
1159 }
1160 }
1161}
1162#[repr(C)]
1163#[derive(Copy, Clone)]
1164pub struct ec_ioctl_sc_idn_t {
1165 pub config_index: u32,
1166 pub drive_no: u8,
1167 pub idn: u16,
1168 pub al_state: ec_al_state_t,
1169 pub data: *const u8,
1170 pub size: usize,
1171}
1172impl Default for ec_ioctl_sc_idn_t {
1173 fn default() -> Self {
1174 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1175 unsafe {
1176 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1177 s.assume_init()
1178 }
1179 }
1180}
1181#[repr(C)]
1182#[derive(Copy, Clone)]
1183pub struct ec_ioctl_sc_flag_t {
1184 pub config_index: u32,
1185 pub key_size: usize,
1186 pub key: *mut ::std::os::raw::c_char,
1187 pub value: i32,
1188}
1189impl Default for ec_ioctl_sc_flag_t {
1190 fn default() -> Self {
1191 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1192 unsafe {
1193 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1194 s.assume_init()
1195 }
1196 }
1197}
1198#[repr(C)]
1199#[derive(Copy, Clone)]
1200pub struct ec_ioctl_domain_state_t {
1201 pub domain_index: u32,
1202 pub state: *mut ec_domain_state_t,
1203}
1204impl Default for ec_ioctl_domain_state_t {
1205 fn default() -> Self {
1206 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1207 unsafe {
1208 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1209 s.assume_init()
1210 }
1211 }
1212}
1213#[repr(C)]
1214#[derive(Copy, Clone)]
1215pub struct ec_ioctl_sdo_request_t {
1216 pub config_index: u32,
1217 pub request_index: u32,
1218 pub sdo_index: u16,
1219 pub sdo_subindex: u8,
1220 pub size: usize,
1221 pub data: *mut u8,
1222 pub timeout: u32,
1223 pub state: ec_request_state_t,
1224}
1225impl Default for ec_ioctl_sdo_request_t {
1226 fn default() -> Self {
1227 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1228 unsafe {
1229 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1230 s.assume_init()
1231 }
1232 }
1233}
1234#[repr(C)]
1235#[derive(Copy, Clone)]
1236pub struct ec_ioctl_reg_request_t {
1237 pub config_index: u32,
1238 pub mem_size: usize,
1239 pub request_index: u32,
1240 pub data: *mut u8,
1241 pub state: ec_request_state_t,
1242 pub new_data: u8,
1243 pub address: u16,
1244 pub transfer_size: usize,
1245}
1246impl Default for ec_ioctl_reg_request_t {
1247 fn default() -> Self {
1248 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1249 unsafe {
1250 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1251 s.assume_init()
1252 }
1253 }
1254}
1255#[repr(C)]
1256#[derive(Copy, Clone)]
1257pub struct ec_ioctl_voe_t {
1258 pub config_index: u32,
1259 pub voe_index: u32,
1260 pub vendor_id: *mut u32,
1261 pub vendor_type: *mut u16,
1262 pub size: usize,
1263 pub data: *mut u8,
1264 pub state: ec_request_state_t,
1265}
1266impl Default for ec_ioctl_voe_t {
1267 fn default() -> Self {
1268 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1269 unsafe {
1270 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1271 s.assume_init()
1272 }
1273 }
1274}
1275#[repr(C)]
1276#[derive(Copy, Clone)]
1277pub struct ec_ioctl_link_state_t {
1278 pub dev_idx: u32,
1279 pub state: *mut ec_master_link_state_t,
1280}
1281impl Default for ec_ioctl_link_state_t {
1282 fn default() -> Self {
1283 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1284 unsafe {
1285 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1286 s.assume_init()
1287 }
1288 }
1289}