/* automatically generated by rust-bindgen 0.70.1 */

#![allow(dead_code, non_camel_case_types, non_snake_case)]

pub const __BITS_PER_LONG: u32 = 64;
pub const __FD_SETSIZE: u32 = 1024;
pub const PPS_VERSION: &[u8; 6] = b"5.3.6\0";
pub const PPS_MAX_SOURCES: u32 = 16;
pub const PPS_API_VERS_1: u32 = 1;
pub const PPS_API_VERS: u32 = 1;
pub const PPS_MAX_NAME_LEN: u32 = 32;
pub const PPS_TIME_INVALID: u32 = 1;
pub const PPS_CAPTUREASSERT: u32 = 1;
pub const PPS_CAPTURECLEAR: u32 = 2;
pub const PPS_CAPTUREBOTH: u32 = 3;
pub const PPS_OFFSETASSERT: u32 = 16;
pub const PPS_OFFSETCLEAR: u32 = 32;
pub const PPS_CANWAIT: u32 = 256;
pub const PPS_CANPOLL: u32 = 512;
pub const PPS_ECHOASSERT: u32 = 64;
pub const PPS_ECHOCLEAR: u32 = 128;
pub const PPS_TSFMT_TSPEC: u32 = 4096;
pub const PPS_TSFMT_NTPFP: u32 = 8192;
pub const PPS_KC_HARDPPS: u32 = 0;
pub const PPS_KC_HARDPPS_PLL: u32 = 1;
pub const PPS_KC_HARDPPS_FLL: u32 = 2;
pub const _IOC_NRBITS: u32 = 8;
pub const _IOC_TYPEBITS: u32 = 8;
pub const _IOC_SIZEBITS: u32 = 14;
pub const _IOC_DIRBITS: u32 = 2;
pub const _IOC_NRMASK: u32 = 255;
pub const _IOC_TYPEMASK: u32 = 255;
pub const _IOC_SIZEMASK: u32 = 16383;
pub const _IOC_DIRMASK: u32 = 3;
pub const _IOC_NRSHIFT: u32 = 0;
pub const _IOC_TYPESHIFT: u32 = 8;
pub const _IOC_SIZESHIFT: u32 = 16;
pub const _IOC_DIRSHIFT: u32 = 30;
pub const _IOC_NONE: u32 = 0;
pub const _IOC_WRITE: u32 = 1;
pub const _IOC_READ: u32 = 2;
pub const IOC_IN: u32 = 1073741824;
pub const IOC_OUT: u32 = 2147483648;
pub const IOC_INOUT: u32 = 3221225472;
pub const IOCSIZE_MASK: u32 = 1073676288;
pub const IOCSIZE_SHIFT: u32 = 16;
pub type __s8 = ::std::os::raw::c_schar;
pub type __u8 = ::std::os::raw::c_uchar;
pub type __s16 = ::std::os::raw::c_short;
pub type __u16 = ::std::os::raw::c_ushort;
pub type __s32 = ::std::os::raw::c_int;
pub type __u32 = ::std::os::raw::c_uint;
pub type __s64 = ::std::os::raw::c_longlong;
pub type __u64 = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __kernel_fd_set {
    pub fds_bits: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___kernel_fd_set() {
    const UNINIT: ::std::mem::MaybeUninit<__kernel_fd_set> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__kernel_fd_set>(),
        128usize,
        "Size of __kernel_fd_set"
    );
    assert_eq!(
        ::std::mem::align_of::<__kernel_fd_set>(),
        8usize,
        "Alignment of __kernel_fd_set"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fds_bits) as usize - ptr as usize },
        0usize,
        "Offset of field: __kernel_fd_set::fds_bits"
    );
}
pub type __kernel_sighandler_t =
    ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
pub type __kernel_key_t = ::std::os::raw::c_int;
pub type __kernel_mqd_t = ::std::os::raw::c_int;
pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
pub type __kernel_long_t = ::std::os::raw::c_long;
pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
pub type __kernel_ino_t = __kernel_ulong_t;
pub type __kernel_mode_t = ::std::os::raw::c_uint;
pub type __kernel_pid_t = ::std::os::raw::c_int;
pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
pub type __kernel_uid_t = ::std::os::raw::c_uint;
pub type __kernel_gid_t = ::std::os::raw::c_uint;
pub type __kernel_suseconds_t = __kernel_long_t;
pub type __kernel_daddr_t = ::std::os::raw::c_int;
pub type __kernel_uid32_t = ::std::os::raw::c_uint;
pub type __kernel_gid32_t = ::std::os::raw::c_uint;
pub type __kernel_size_t = __kernel_ulong_t;
pub type __kernel_ssize_t = __kernel_long_t;
pub type __kernel_ptrdiff_t = __kernel_long_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __kernel_fsid_t {
    pub val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___kernel_fsid_t() {
    const UNINIT: ::std::mem::MaybeUninit<__kernel_fsid_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<__kernel_fsid_t>(),
        8usize,
        "Size of __kernel_fsid_t"
    );
    assert_eq!(
        ::std::mem::align_of::<__kernel_fsid_t>(),
        4usize,
        "Alignment of __kernel_fsid_t"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
        0usize,
        "Offset of field: __kernel_fsid_t::val"
    );
}
pub type __kernel_off_t = __kernel_long_t;
pub type __kernel_loff_t = ::std::os::raw::c_longlong;
pub type __kernel_old_time_t = __kernel_long_t;
pub type __kernel_time_t = __kernel_long_t;
pub type __kernel_time64_t = ::std::os::raw::c_longlong;
pub type __kernel_clock_t = __kernel_long_t;
pub type __kernel_timer_t = ::std::os::raw::c_int;
pub type __kernel_clockid_t = ::std::os::raw::c_int;
pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
pub type __le16 = __u16;
pub type __be16 = __u16;
pub type __le32 = __u32;
pub type __be32 = __u32;
pub type __le64 = __u64;
pub type __be64 = __u64;
pub type __sum16 = __u16;
pub type __wsum = __u32;
pub type __poll_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_ktime {
    pub sec: __s64,
    pub nsec: __s32,
    pub flags: __u32,
}
#[test]
fn bindgen_test_layout_pps_ktime() {
    const UNINIT: ::std::mem::MaybeUninit<pps_ktime> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_ktime>(),
        16usize,
        "Size of pps_ktime"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_ktime>(),
        8usize,
        "Alignment of pps_ktime"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_ktime::sec"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize },
        8usize,
        "Offset of field: pps_ktime::nsec"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        12usize,
        "Offset of field: pps_ktime::flags"
    );
}
#[repr(C, packed(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_ktime_compat {
    pub sec: __s64,
    pub nsec: __s32,
    pub flags: __u32,
}
#[test]
fn bindgen_test_layout_pps_ktime_compat() {
    const UNINIT: ::std::mem::MaybeUninit<pps_ktime_compat> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_ktime_compat>(),
        16usize,
        "Size of pps_ktime_compat"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_ktime_compat>(),
        4usize,
        "Alignment of pps_ktime_compat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_ktime_compat::sec"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize },
        8usize,
        "Offset of field: pps_ktime_compat::nsec"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
        12usize,
        "Offset of field: pps_ktime_compat::flags"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_kinfo {
    pub assert_sequence: __u32,
    pub clear_sequence: __u32,
    pub assert_tu: pps_ktime,
    pub clear_tu: pps_ktime,
    pub current_mode: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pps_kinfo() {
    const UNINIT: ::std::mem::MaybeUninit<pps_kinfo> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_kinfo>(),
        48usize,
        "Size of pps_kinfo"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_kinfo>(),
        8usize,
        "Alignment of pps_kinfo"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).assert_sequence) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_kinfo::assert_sequence"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clear_sequence) as usize - ptr as usize },
        4usize,
        "Offset of field: pps_kinfo::clear_sequence"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).assert_tu) as usize - ptr as usize },
        8usize,
        "Offset of field: pps_kinfo::assert_tu"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clear_tu) as usize - ptr as usize },
        24usize,
        "Offset of field: pps_kinfo::clear_tu"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_mode) as usize - ptr as usize },
        40usize,
        "Offset of field: pps_kinfo::current_mode"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_kinfo_compat {
    pub assert_sequence: __u32,
    pub clear_sequence: __u32,
    pub assert_tu: pps_ktime_compat,
    pub clear_tu: pps_ktime_compat,
    pub current_mode: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pps_kinfo_compat() {
    const UNINIT: ::std::mem::MaybeUninit<pps_kinfo_compat> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_kinfo_compat>(),
        44usize,
        "Size of pps_kinfo_compat"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_kinfo_compat>(),
        4usize,
        "Alignment of pps_kinfo_compat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).assert_sequence) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_kinfo_compat::assert_sequence"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clear_sequence) as usize - ptr as usize },
        4usize,
        "Offset of field: pps_kinfo_compat::clear_sequence"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).assert_tu) as usize - ptr as usize },
        8usize,
        "Offset of field: pps_kinfo_compat::assert_tu"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clear_tu) as usize - ptr as usize },
        24usize,
        "Offset of field: pps_kinfo_compat::clear_tu"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_mode) as usize - ptr as usize },
        40usize,
        "Offset of field: pps_kinfo_compat::current_mode"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_kparams {
    pub api_version: ::std::os::raw::c_int,
    pub mode: ::std::os::raw::c_int,
    pub assert_off_tu: pps_ktime,
    pub clear_off_tu: pps_ktime,
}
#[test]
fn bindgen_test_layout_pps_kparams() {
    const UNINIT: ::std::mem::MaybeUninit<pps_kparams> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_kparams>(),
        40usize,
        "Size of pps_kparams"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_kparams>(),
        8usize,
        "Alignment of pps_kparams"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).api_version) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_kparams::api_version"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
        4usize,
        "Offset of field: pps_kparams::mode"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).assert_off_tu) as usize - ptr as usize },
        8usize,
        "Offset of field: pps_kparams::assert_off_tu"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clear_off_tu) as usize - ptr as usize },
        24usize,
        "Offset of field: pps_kparams::clear_off_tu"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_fdata {
    pub info: pps_kinfo,
    pub timeout: pps_ktime,
}
#[test]
fn bindgen_test_layout_pps_fdata() {
    const UNINIT: ::std::mem::MaybeUninit<pps_fdata> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_fdata>(),
        64usize,
        "Size of pps_fdata"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_fdata>(),
        8usize,
        "Alignment of pps_fdata"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_fdata::info"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
        48usize,
        "Offset of field: pps_fdata::timeout"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_fdata_compat {
    pub info: pps_kinfo_compat,
    pub timeout: pps_ktime_compat,
}
#[test]
fn bindgen_test_layout_pps_fdata_compat() {
    const UNINIT: ::std::mem::MaybeUninit<pps_fdata_compat> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_fdata_compat>(),
        60usize,
        "Size of pps_fdata_compat"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_fdata_compat>(),
        4usize,
        "Alignment of pps_fdata_compat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_fdata_compat::info"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
        44usize,
        "Offset of field: pps_fdata_compat::timeout"
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pps_bind_args {
    pub tsformat: ::std::os::raw::c_int,
    pub edge: ::std::os::raw::c_int,
    pub consumer: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pps_bind_args() {
    const UNINIT: ::std::mem::MaybeUninit<pps_bind_args> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<pps_bind_args>(),
        12usize,
        "Size of pps_bind_args"
    );
    assert_eq!(
        ::std::mem::align_of::<pps_bind_args>(),
        4usize,
        "Alignment of pps_bind_args"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tsformat) as usize - ptr as usize },
        0usize,
        "Offset of field: pps_bind_args::tsformat"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).edge) as usize - ptr as usize },
        4usize,
        "Offset of field: pps_bind_args::edge"
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).consumer) as usize - ptr as usize },
        8usize,
        "Offset of field: pps_bind_args::consumer"
    );
}
