public/rust/fuchsia-ddk/fuchsia-ddk-sys/src/lib.rs - garnet - Git at Google

 // Copyright 2017 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #![allow(non_camel_case_types,non_snake_case)]
 #![deny(warnings)]

 extern crate fuchsia_zircon as zircon;

 use zircon::sys as sys;
 use std::os::raw::c_char;

 // References to Zircon DDK's driver.h

 // Copied from fuchsia-zircon-sys.
 macro_rules! multiconst {
     ($typename:ident, [$($rawname:ident = $value:expr;)*]) => {
         $(
             pub const $rawname: $typename = $value;
         )*
     }
 }

 // Opaque structs
 #[repr(u8)]
 pub enum zx_device_t {
     variant1,
 }

 #[repr(u8)]
 pub enum zx_device_prop_t {
     variant1,
 }

 #[repr(u8)]
 pub enum zx_driver_t {
     variant1,
 }

 #[repr(C)]
 pub struct zx_driver_rec_t {
     pub ops: *const zx_driver_ops_t,
     pub driver: *mut zx_driver_t,
     pub log_flags: u32,
 }

 pub const ZX_DEVICE_NAME_MAX: usize = 31;

 #[repr(C)]
 pub struct list_node_t {
     pub prev: *mut list_node_t,
     pub next: *mut list_node_t,
 }

 impl Default for list_node_t {
     fn default() -> Self {
         list_node_t {
             prev: std::ptr::null_mut(),
             next: std::ptr::null_mut(),
         }
     }
 }

 const DRIVER_OPS_VERSION: u64 = 0x2b3490fa40d9f452;

 #[repr(C)]
 pub struct zx_driver_ops_t {
     pub __version: u64,

     pub init: Option<unsafe extern "C" fn (out_ctx: *mut *mut u8) -> sys::zx_status_t>,
     pub bind: Option<unsafe extern "C" fn (ctx: *mut u8, device: *mut zx_device_t) -> sys::zx_status_t>,
     pub create: Option<unsafe extern "C" fn (ctx: *mut u8, parent: *mut zx_device_t, name: *const c_char, args: *const c_char, rpc_channel: sys::zx_handle_t) -> sys::zx_status_t>,
     pub release: Option<unsafe extern "C" fn (ctx: *mut u8)>,
 }

 // This is needed instead of Default::default() because the latter can't be called in a static
 // context.
 pub const DEFAULT_DRIVER_OPS: zx_driver_ops_t = zx_driver_ops_t {
     __version: DRIVER_OPS_VERSION,
     init: None,
     bind: None,
     create: None,
     release: None,
 };

 impl Default for zx_driver_ops_t {
     fn default() -> Self {
         DEFAULT_DRIVER_OPS
     }
 }

 const DEVICE_OPS_VERSION: u64 = 0xc9410d2a24f57424;

 #[repr(C)]
 pub struct zx_protocol_device_t {
     pub __version: u64,

     pub get_protocol: Option<unsafe extern "C" fn (ctx: *mut u8, proto_id: u32, protocol: *mut u8) -> sys::zx_status_t>,
     pub open: Option<unsafe extern "C" fn (ctx: *mut u8, dev_out: *mut *mut zx_device_t, flags: u32) -> sys::zx_status_t>,
     pub open_at: Option<unsafe extern "C" fn (ctx: *mut u8, dev_out: *mut *mut zx_device_t, path: *const c_char, flags: u32) -> sys::zx_status_t>,
     pub close: Option<unsafe extern "C" fn (ctx: *mut u8, flags: u32) -> sys::zx_status_t>,
     pub unbind: Option<unsafe extern "C" fn (ctx: *mut u8)>,
     pub release: Option<unsafe extern "C" fn (ctx: *mut u8)>,
     pub read: Option<unsafe extern "C" fn (ctx: *mut u8, buf: *mut u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t>,
     pub write: Option<unsafe extern "C" fn (ctx: *mut u8, buf: *const u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t>,
     pub get_size: Option<unsafe extern "C" fn (ctx: *mut u8) -> sys::zx_off_t>,
     pub ioctl: Option<unsafe extern "C" fn (ctx: *mut u8, op: u32, in_buf: *const u8, in_len: usize, out_buf: *mut u8, out_len: usize, out_actual: *mut usize) -> sys::zx_status_t>,
     pub suspend: Option<unsafe extern "C" fn (ctx: *mut u8, flags: u32) -> sys::zx_status_t>,
     pub resume: Option<unsafe extern "C" fn (ctx: *mut u8, flags: u32) -> sys::zx_status_t>,
     pub rxrpc: Option<unsafe extern "C" fn (ctx: *mut u8, channel: sys::zx_handle_t) -> sys::zx_status_t>,
 }

 // This is needed instead of Default::default() because the latter can't be called in a static
 // context.
 pub const DEFAULT_PROTOCOL_DEVICE: zx_protocol_device_t = zx_protocol_device_t {
     __version: DEVICE_OPS_VERSION,
     get_protocol: None,
     open: None,
     open_at: None,
     close: None,
     unbind: None,
     release: None,
     read: None,
     write: None,
     get_size: None,
     ioctl: None,
     suspend: None,
     resume: None,
     rxrpc: None,
 };

 impl Default for zx_protocol_device_t {
     fn default() -> Self {
         DEFAULT_PROTOCOL_DEVICE
     }
 }

 pub type device_add_flags_t = u32;

 multiconst!(device_add_flags_t, [
     DEVICE_ADD_NONE         = 0;
     DEVICE_ADD_NON_BINDABLE = 1 << 0;
     DEVICE_ADD_INSTANCE     = 1 << 1;
     DEVICE_ADD_MUST_ISOLATE = 1 << 2;
     DEVICE_ADD_INVISIBLE    = 1 << 3;
 ]);

 // Device Manager API
 const DEVICE_ADD_ARGS_VERSION: u64 = 0x96a64134d56e88e3;

 #[repr(C)]
 pub struct device_add_args_t {
     pub version: u64,
     pub name: *const c_char,
     pub ctx: *mut u8,
     pub ops: *mut zx_protocol_device_t,
     pub props: *mut zx_device_prop_t,
     pub prop_count: u32,
     pub proto_id: u32,
     pub proto_ops: *mut u8,
     pub proxy_args: *const c_char,
     pub flags: device_add_flags_t,
 }

 impl Default for device_add_args_t {
     fn default() -> Self {
         device_add_args_t {
             version: DEVICE_ADD_ARGS_VERSION,
             name: std::ptr::null_mut(),
             ctx: std::ptr::null_mut(),
             ops: std::ptr::null_mut(),
             props: std::ptr::null_mut(),
             prop_count: 0,
             proto_id: 0,
             proto_ops: std::ptr::null_mut(),
             proxy_args: std::ptr::null_mut(),
             flags: DEVICE_ADD_NON_BINDABLE,
         }
     }
 }

 // USB request types
 pub type usb_request_type_t = u8;

 multiconst!(usb_request_type_t, [
     USB_DIR_OUT         = 0 << 7;
     USB_DIR_IN          = 1 << 7;
     USB_DIR_MASK        = 1 << 7;
     USB_TYPE_STANDARD   = 0 << 5;
     USB_TYPE_CLASS      = 1 << 5;
     USB_TYPE_VENDOR     = 2 << 5;
     USB_TYPE_MASK       = 3 << 5;
     USB_RECIP_DEVICE    = 0 << 0;
     USB_RECIP_INTERFACE = 1 << 0;
     USB_RECIP_ENDPOINT  = 2 << 0;
     USB_RECIP_OTHER     = 3 << 0;
     USB_RECIP_MASK      = 0x1f << 0;
 ]);

 // USB standard request values
 multiconst!(u8, [
     USB_REQ_GET_STATUS        = 0x00;
     USB_REQ_CLEAR_FEATURE     = 0x01;
     USB_REQ_SET_FEATURE       = 0x03;
     USB_REQ_SET_ADDRESS       = 0x05;
     USB_REQ_GET_DESCRIPTOR    = 0x06;
     USB_REQ_SET_DESCRIPTOR    = 0x07;
     USB_REQ_GET_CONFIGURATION = 0x08;
     USB_REQ_SET_CONFIGURATION = 0x09;
     USB_REQ_GET_INTERFACE     = 0x0a;
     USB_REQ_SET_INTERFACE     = 0x0b;
     USB_REQ_SYNCH_FRAME       = 0x0c;
 ]);

 // USB device/interface classes
 #[repr(u8)]
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum usb_class_t {
     USB_CLASS_AUDIO      = 0x01,
     USB_CLASS_COMM       = 0x02,
     USB_CLASS_HID        = 0x03,
     USB_CLASS_PHYSICAL   = 0x05,
     USB_CLASS_IMAGING    = 0x06,
     USB_CLASS_PRINTER    = 0x07,
     USB_CLASS_MSC        = 0x08,
     USB_CLASS_HUB        = 0x09,
     USB_CLASS_CDC        = 0x0a,
     USB_CLASS_CCID       = 0x0b,
     USB_CLASS_SECURITY   = 0x0d,
     USB_CLASS_VIDEO      = 0x0e,
     USB_CLASS_HEALTHCARE = 0x0f,
     USB_CLASS_DIAGNOSTIC = 0xdc,
     USB_CLASS_WIRELESS   = 0xe0,
     USB_CLASS_MISC       = 0xef,
     USB_CLASS_VENDOR     = 0xff,
 }

 pub const USB_SUBCLASS_MSC_SCSI: u8      = 0x06;
 pub const USB_PROTOCOL_MSC_BULK_ONLY: u8 = 0x50;

 // USB descriptor types
 multiconst!(u8, [
     USB_DT_DEVICE                = 0x01;
     USB_DT_CONFIG                = 0x02;
     USB_DT_STRING                = 0x03;
     USB_DT_INTERFACE             = 0x04;
     USB_DT_ENDPOINT              = 0x05;
     USB_DT_DEVICE_QUALIFIER      = 0x06;
     USB_DT_OTHER_SPEED_CONFIG    = 0x07;
     USB_DT_INTERFACE_POWER       = 0x08;
     USB_DT_INTERFACE_ASSOCIATION = 0x0b;
     USB_DT_HID                   = 0x21;
     USB_DT_HIDREPORT             = 0x22;
     USB_DT_HIDPHYSICAL           = 0x23;
     USB_DT_CS_INTERFACE          = 0x24;
     USB_DT_CS_ENDPOINT           = 0x25;
     USB_DT_SS_EP_COMPANION       = 0x30;
     USB_DT_SS_ISOCH_EP_COMPANION = 0x31;
 ]);

 pub const ZX_PROTOCOL_USB: u32 = 0x70555342; // 'pUSB'

 #[repr(C)]
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum usb_speed_t {
     USB_SPEED_UNDEFINED = 0,
     USB_SPEED_FULL = 1,
     USB_SPEED_LOW = 2,
     USB_SPEED_HIGH = 3,
     USB_SPEED_SUPER = 4,
 }

 // Opaque struct
 #[repr(u8)]
 pub enum usb_request_t {
     variant1,
 }

 #[repr(C, packed)]
 pub struct usb_device_descriptor_t {
     pub bLength: u8,
     pub bDescriptorType: u8,
     pub bcdUSB: u16,
     pub bDeviceClass: u8,
     pub bDeviceSubClass: u8,
     pub bDeviceProtocol: u8,
     pub bMaxPacketSize0: u8,
     pub idVendor: u16,
     pub idProduct: u16,
     pub bcdDevice: u16,
     pub iManufacturer: u8,
     pub iProduct: u8,
     pub iSerialNumber: u8,
     pub bNumConfigurations: u8,
 }

 impl Default for usb_device_descriptor_t {
     fn default() -> Self {
         usb_device_descriptor_t {
             bLength: 0,
             bDescriptorType: 0,
             bcdUSB: 0,
             bDeviceClass: 0,
             bDeviceSubClass: 0,
             bDeviceProtocol: 0,
             bMaxPacketSize0: 0,
             idVendor: 0,
             idProduct: 0,
             bcdDevice: 0,
             iManufacturer: 0,
             iProduct: 0,
             iSerialNumber: 0,
             bNumConfigurations: 0,
         }
     }
 }

 #[repr(C, packed)]
 pub struct usb_configuration_descriptor_t {
     pub bLength: u8,
     pub bDescriptorType: u8,
     pub wTotalLength: u16,
     pub bNumInterfaces: u8,
     pub bConfigurationValue: u8,
     pub iConfiguration: u8,
     pub bmAttributes: u8,
     pub bMaxPower: u8,
 }

 #[repr(C, packed)]
 pub struct usb_interface_descriptor_t {
     pub bLength: u8,
     pub bDescriptorType: u8,
     pub bInterfaceNumber: u8,
     pub bAlternateSetting: u8,
     pub bNumEndpoints: u8,
     pub bInterfaceClass: u8,
     pub bInterfaceSubClass: u8,
     pub bInterfaceProtocol: u8,
     pub iInterface: u8,
 }

 #[repr(C, packed)]
 pub struct usb_endpoint_descriptor_t {
     pub bLength: u8,
     pub bDescriptorType: u8,
     pub bEndpointAddress: u8,
     pub bmAttributes: u8,
     pub wMaxPacketSize: u16,
     pub bInterval: u8,
 }

 #[repr(C)]
 pub struct usb_protocol_ops_t {
     pub control: unsafe extern "C" fn (ctx: *mut u8, request_type: usb_request_type_t, request: u8,
         value: u16, index: u16, data: *mut u8, length: usize, timeout: sys::zx_time_t,
         out_length: *mut usize) -> sys::zx_status_t,
     pub request_queue: unsafe extern "C" fn (ctx: *mut u8, usb_request: *mut usb_request_t),
     pub get_speed: unsafe extern "C" fn (ctx: *mut u8) -> usb_speed_t,
     pub set_interface: unsafe extern "C" fn (ctx: *mut u8, interface_number: i32, alt_setting: i32)
         -> sys::zx_status_t,
     pub set_configuration: unsafe extern "C" fn (ctx: *mut u8, configuration: i32) -> sys::zx_status_t,
     pub reset_endpoint: unsafe extern "C" fn (ctx: *mut u8, ep_address: u8) -> sys::zx_status_t,
     pub get_max_transfer_size: unsafe extern "C" fn (ctx: *mut u8, ep_address: u8) -> usize,
     pub get_device_id: unsafe extern "C" fn (ctx: *mut u8) -> u32,
     pub get_descriptor_list: unsafe extern "C" fn (ctx: *mut u8, out_descriptors: *mut *mut u8,
         out_length: *mut usize) -> sys::zx_status_t,
     pub get_additional_descriptor_list: unsafe extern "C" fn (ctx: *mut u8, out_descriptors: *mut *mut u8,
         out_length: *mut usize) -> sys::zx_status_t,
     pub claim_interface: unsafe extern "C" fn (ctx: *mut u8, intf: *mut usb_interface_descriptor_t,
         length: usize) -> sys::zx_status_t,
     pub cancel_all: unsafe extern "C" fn (ctx: *mut u8, ep_address: u8) -> sys::zx_status_t,
 }

 #[repr(C)]
 pub struct usb_protocol_t {
     pub ops: *mut usb_protocol_ops_t,
     pub ctx: *mut u8,
 }

 impl Default for usb_protocol_t {
     fn default() -> Self {
         usb_protocol_t {
             ops: std::ptr::null_mut(),
             ctx: std::ptr::null_mut(),
         }
     }
 }

 #[link(name = "ddk")]
 extern "C" {
     pub static __zircon_driver_rec__: zx_driver_rec_t;

     pub fn device_add_from_driver(driver: *mut zx_driver_t, parent: *mut zx_device_t, args: *mut device_add_args_t, out: *mut *mut zx_device_t) -> sys::zx_status_t;
     pub fn device_remove(device: *mut zx_device_t) -> sys::zx_status_t;
     pub fn device_rebind(device: *mut zx_device_t) -> sys::zx_status_t;
     pub fn load_firmware(device: *mut zx_device_t, path: *const c_char, fw: *mut sys::zx_handle_t, size: *mut usize) -> sys::zx_status_t;
     pub fn device_get_name(dev: *mut zx_device_t) -> *const c_char;
     pub fn device_get_parent(dev: *mut zx_device_t) -> *mut zx_device_t;
     pub fn device_get_protocol(dev: *mut zx_device_t, proto_id: u32, protocol: *mut u8) -> sys::zx_status_t;
     pub fn device_read(dev: *mut zx_device_t, buf: *mut u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t;
     pub fn device_write(dev: *mut zx_device_t, buf: *const u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t;
     pub fn device_get_size(dev: *mut zx_device_t) -> sys::zx_off_t;
     pub fn device_ioctl(dev: *mut zx_device_t, op: u32, in_buf: *const u8, in_len: usize, out_buf: *mut u8, out_len: usize, out_actual: *mut usize) -> sys::zx_status_t;
     pub fn device_state_clr_set(dev: *mut zx_device_t, clearflag: sys::zx_signals_t, setflag: sys::zx_signals_t);
 }
	// Copyright 2017 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#![allow(non_camel_case_types,non_snake_case)]
	#![deny(warnings)]

	extern crate fuchsia_zircon as zircon;

	use zircon::sys as sys;
	use std::os::raw::c_char;

	// References to Zircon DDK's driver.h

	// Copied from fuchsia-zircon-sys.
	macro_rules! multiconst {
	($typename:ident, [$($rawname:ident = $value:expr;)*]) => {
	$(
	pub const $rawname: $typename = $value;
	)*
	}
	}

	// Opaque structs
	#[repr(u8)]
	pub enum zx_device_t {
	variant1,
	}

	#[repr(u8)]
	pub enum zx_device_prop_t {
	variant1,
	}

	#[repr(u8)]
	pub enum zx_driver_t {
	variant1,
	}

	#[repr(C)]
	pub struct zx_driver_rec_t {
	pub ops: *const zx_driver_ops_t,
	pub driver: *mut zx_driver_t,
	pub log_flags: u32,
	}

	pub const ZX_DEVICE_NAME_MAX: usize = 31;

	#[repr(C)]
	pub struct list_node_t {
	pub prev: *mut list_node_t,
	pub next: *mut list_node_t,
	}

	impl Default for list_node_t {
	fn default() -> Self {
	list_node_t {
	prev: std::ptr::null_mut(),
	next: std::ptr::null_mut(),
	}
	}
	}

	const DRIVER_OPS_VERSION: u64 = 0x2b3490fa40d9f452;

	#[repr(C)]
	pub struct zx_driver_ops_t {
	pub __version: u64,

	pub init: Option<unsafe extern "C" fn (out_ctx: mut mut u8) -> sys::zx_status_t>,
	pub bind: Option<unsafe extern "C" fn (ctx: mut u8, device: mut zx_device_t) -> sys::zx_status_t>,
	pub create: Option<unsafe extern "C" fn (ctx: mut u8, parent: mut zx_device_t, name: const c_char, args: const c_char, rpc_channel: sys::zx_handle_t) -> sys::zx_status_t>,
	pub release: Option<unsafe extern "C" fn (ctx: *mut u8)>,
	}

	// This is needed instead of Default::default() because the latter can't be called in a static
	// context.
	pub const DEFAULT_DRIVER_OPS: zx_driver_ops_t = zx_driver_ops_t {
	__version: DRIVER_OPS_VERSION,
	init: None,
	bind: None,
	create: None,
	release: None,
	};

	impl Default for zx_driver_ops_t {
	fn default() -> Self {
	DEFAULT_DRIVER_OPS
	}
	}

	const DEVICE_OPS_VERSION: u64 = 0xc9410d2a24f57424;

	#[repr(C)]
	pub struct zx_protocol_device_t {
	pub __version: u64,

	pub get_protocol: Option<unsafe extern "C" fn (ctx: mut u8, proto_id: u32, protocol: mut u8) -> sys::zx_status_t>,
	pub open: Option<unsafe extern "C" fn (ctx: mut u8, dev_out: mut *mut zx_device_t, flags: u32) -> sys::zx_status_t>,
	pub open_at: Option<unsafe extern "C" fn (ctx: mut u8, dev_out: mut mut zx_device_t, path: const c_char, flags: u32) -> sys::zx_status_t>,
	pub close: Option<unsafe extern "C" fn (ctx: *mut u8, flags: u32) -> sys::zx_status_t>,
	pub unbind: Option<unsafe extern "C" fn (ctx: *mut u8)>,
	pub release: Option<unsafe extern "C" fn (ctx: *mut u8)>,
	pub read: Option<unsafe extern "C" fn (ctx: mut u8, buf: mut u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t>,
	pub write: Option<unsafe extern "C" fn (ctx: mut u8, buf: const u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t>,
	pub get_size: Option<unsafe extern "C" fn (ctx: *mut u8) -> sys::zx_off_t>,
	pub ioctl: Option<unsafe extern "C" fn (ctx: mut u8, op: u32, in_buf: const u8, in_len: usize, out_buf: mut u8, out_len: usize, out_actual: mut usize) -> sys::zx_status_t>,
	pub suspend: Option<unsafe extern "C" fn (ctx: *mut u8, flags: u32) -> sys::zx_status_t>,
	pub resume: Option<unsafe extern "C" fn (ctx: *mut u8, flags: u32) -> sys::zx_status_t>,
	pub rxrpc: Option<unsafe extern "C" fn (ctx: *mut u8, channel: sys::zx_handle_t) -> sys::zx_status_t>,
	}

	// This is needed instead of Default::default() because the latter can't be called in a static
	// context.
	pub const DEFAULT_PROTOCOL_DEVICE: zx_protocol_device_t = zx_protocol_device_t {
	__version: DEVICE_OPS_VERSION,
	get_protocol: None,
	open: None,
	open_at: None,
	close: None,
	unbind: None,
	release: None,
	read: None,
	write: None,
	get_size: None,
	ioctl: None,
	suspend: None,
	resume: None,
	rxrpc: None,
	};

	impl Default for zx_protocol_device_t {
	fn default() -> Self {
	DEFAULT_PROTOCOL_DEVICE
	}
	}

	pub type device_add_flags_t = u32;

	multiconst!(device_add_flags_t, [
	DEVICE_ADD_NONE = 0;
	DEVICE_ADD_NON_BINDABLE = 1 << 0;
	DEVICE_ADD_INSTANCE = 1 << 1;
	DEVICE_ADD_MUST_ISOLATE = 1 << 2;
	DEVICE_ADD_INVISIBLE = 1 << 3;
	]);

	// Device Manager API
	const DEVICE_ADD_ARGS_VERSION: u64 = 0x96a64134d56e88e3;

	#[repr(C)]
	pub struct device_add_args_t {
	pub version: u64,
	pub name: *const c_char,
	pub ctx: *mut u8,
	pub ops: *mut zx_protocol_device_t,
	pub props: *mut zx_device_prop_t,
	pub prop_count: u32,
	pub proto_id: u32,
	pub proto_ops: *mut u8,
	pub proxy_args: *const c_char,
	pub flags: device_add_flags_t,
	}

	impl Default for device_add_args_t {
	fn default() -> Self {
	device_add_args_t {
	version: DEVICE_ADD_ARGS_VERSION,
	name: std::ptr::null_mut(),
	ctx: std::ptr::null_mut(),
	ops: std::ptr::null_mut(),
	props: std::ptr::null_mut(),
	prop_count: 0,
	proto_id: 0,
	proto_ops: std::ptr::null_mut(),
	proxy_args: std::ptr::null_mut(),
	flags: DEVICE_ADD_NON_BINDABLE,
	}
	}
	}

	// USB request types
	pub type usb_request_type_t = u8;

	multiconst!(usb_request_type_t, [
	USB_DIR_OUT = 0 << 7;
	USB_DIR_IN = 1 << 7;
	USB_DIR_MASK = 1 << 7;
	USB_TYPE_STANDARD = 0 << 5;
	USB_TYPE_CLASS = 1 << 5;
	USB_TYPE_VENDOR = 2 << 5;
	USB_TYPE_MASK = 3 << 5;
	USB_RECIP_DEVICE = 0 << 0;
	USB_RECIP_INTERFACE = 1 << 0;
	USB_RECIP_ENDPOINT = 2 << 0;
	USB_RECIP_OTHER = 3 << 0;
	USB_RECIP_MASK = 0x1f << 0;
	]);

	// USB standard request values
	multiconst!(u8, [
	USB_REQ_GET_STATUS = 0x00;
	USB_REQ_CLEAR_FEATURE = 0x01;
	USB_REQ_SET_FEATURE = 0x03;
	USB_REQ_SET_ADDRESS = 0x05;
	USB_REQ_GET_DESCRIPTOR = 0x06;
	USB_REQ_SET_DESCRIPTOR = 0x07;
	USB_REQ_GET_CONFIGURATION = 0x08;
	USB_REQ_SET_CONFIGURATION = 0x09;
	USB_REQ_GET_INTERFACE = 0x0a;
	USB_REQ_SET_INTERFACE = 0x0b;
	USB_REQ_SYNCH_FRAME = 0x0c;
	]);

	// USB device/interface classes
	#[repr(u8)]
	#[derive(Debug, Copy, Clone, Eq, PartialEq)]
	pub enum usb_class_t {
	USB_CLASS_AUDIO = 0x01,
	USB_CLASS_COMM = 0x02,
	USB_CLASS_HID = 0x03,
	USB_CLASS_PHYSICAL = 0x05,
	USB_CLASS_IMAGING = 0x06,
	USB_CLASS_PRINTER = 0x07,
	USB_CLASS_MSC = 0x08,
	USB_CLASS_HUB = 0x09,
	USB_CLASS_CDC = 0x0a,
	USB_CLASS_CCID = 0x0b,
	USB_CLASS_SECURITY = 0x0d,
	USB_CLASS_VIDEO = 0x0e,
	USB_CLASS_HEALTHCARE = 0x0f,
	USB_CLASS_DIAGNOSTIC = 0xdc,
	USB_CLASS_WIRELESS = 0xe0,
	USB_CLASS_MISC = 0xef,
	USB_CLASS_VENDOR = 0xff,
	}

	pub const USB_SUBCLASS_MSC_SCSI: u8 = 0x06;
	pub const USB_PROTOCOL_MSC_BULK_ONLY: u8 = 0x50;

	// USB descriptor types
	multiconst!(u8, [
	USB_DT_DEVICE = 0x01;
	USB_DT_CONFIG = 0x02;
	USB_DT_STRING = 0x03;
	USB_DT_INTERFACE = 0x04;
	USB_DT_ENDPOINT = 0x05;
	USB_DT_DEVICE_QUALIFIER = 0x06;
	USB_DT_OTHER_SPEED_CONFIG = 0x07;
	USB_DT_INTERFACE_POWER = 0x08;
	USB_DT_INTERFACE_ASSOCIATION = 0x0b;
	USB_DT_HID = 0x21;
	USB_DT_HIDREPORT = 0x22;
	USB_DT_HIDPHYSICAL = 0x23;
	USB_DT_CS_INTERFACE = 0x24;
	USB_DT_CS_ENDPOINT = 0x25;
	USB_DT_SS_EP_COMPANION = 0x30;
	USB_DT_SS_ISOCH_EP_COMPANION = 0x31;
	]);

	pub const ZX_PROTOCOL_USB: u32 = 0x70555342; // 'pUSB'

	#[repr(C)]
	#[derive(Debug, Copy, Clone, Eq, PartialEq)]
	pub enum usb_speed_t {
	USB_SPEED_UNDEFINED = 0,
	USB_SPEED_FULL = 1,
	USB_SPEED_LOW = 2,
	USB_SPEED_HIGH = 3,
	USB_SPEED_SUPER = 4,
	}

	// Opaque struct
	#[repr(u8)]
	pub enum usb_request_t {
	variant1,
	}

	#[repr(C, packed)]
	pub struct usb_device_descriptor_t {
	pub bLength: u8,
	pub bDescriptorType: u8,
	pub bcdUSB: u16,
	pub bDeviceClass: u8,
	pub bDeviceSubClass: u8,
	pub bDeviceProtocol: u8,
	pub bMaxPacketSize0: u8,
	pub idVendor: u16,
	pub idProduct: u16,
	pub bcdDevice: u16,
	pub iManufacturer: u8,
	pub iProduct: u8,
	pub iSerialNumber: u8,
	pub bNumConfigurations: u8,
	}

	impl Default for usb_device_descriptor_t {
	fn default() -> Self {
	usb_device_descriptor_t {
	bLength: 0,
	bDescriptorType: 0,
	bcdUSB: 0,
	bDeviceClass: 0,
	bDeviceSubClass: 0,
	bDeviceProtocol: 0,
	bMaxPacketSize0: 0,
	idVendor: 0,
	idProduct: 0,
	bcdDevice: 0,
	iManufacturer: 0,
	iProduct: 0,
	iSerialNumber: 0,
	bNumConfigurations: 0,
	}
	}
	}

	#[repr(C, packed)]
	pub struct usb_configuration_descriptor_t {
	pub bLength: u8,
	pub bDescriptorType: u8,
	pub wTotalLength: u16,
	pub bNumInterfaces: u8,
	pub bConfigurationValue: u8,
	pub iConfiguration: u8,
	pub bmAttributes: u8,
	pub bMaxPower: u8,
	}

	#[repr(C, packed)]
	pub struct usb_interface_descriptor_t {
	pub bLength: u8,
	pub bDescriptorType: u8,
	pub bInterfaceNumber: u8,
	pub bAlternateSetting: u8,
	pub bNumEndpoints: u8,
	pub bInterfaceClass: u8,
	pub bInterfaceSubClass: u8,
	pub bInterfaceProtocol: u8,
	pub iInterface: u8,
	}

	#[repr(C, packed)]
	pub struct usb_endpoint_descriptor_t {
	pub bLength: u8,
	pub bDescriptorType: u8,
	pub bEndpointAddress: u8,
	pub bmAttributes: u8,
	pub wMaxPacketSize: u16,
	pub bInterval: u8,
	}

	#[repr(C)]
	pub struct usb_protocol_ops_t {
	pub control: unsafe extern "C" fn (ctx: *mut u8, request_type: usb_request_type_t, request: u8,
	value: u16, index: u16, data: *mut u8, length: usize, timeout: sys::zx_time_t,
	out_length: *mut usize) -> sys::zx_status_t,
	pub request_queue: unsafe extern "C" fn (ctx: mut u8, usb_request: mut usb_request_t),
	pub get_speed: unsafe extern "C" fn (ctx: *mut u8) -> usb_speed_t,
	pub set_interface: unsafe extern "C" fn (ctx: *mut u8, interface_number: i32, alt_setting: i32)
	-> sys::zx_status_t,
	pub set_configuration: unsafe extern "C" fn (ctx: *mut u8, configuration: i32) -> sys::zx_status_t,
	pub reset_endpoint: unsafe extern "C" fn (ctx: *mut u8, ep_address: u8) -> sys::zx_status_t,
	pub get_max_transfer_size: unsafe extern "C" fn (ctx: *mut u8, ep_address: u8) -> usize,
	pub get_device_id: unsafe extern "C" fn (ctx: *mut u8) -> u32,
	pub get_descriptor_list: unsafe extern "C" fn (ctx: mut u8, out_descriptors: mut *mut u8,
	out_length: *mut usize) -> sys::zx_status_t,
	pub get_additional_descriptor_list: unsafe extern "C" fn (ctx: mut u8, out_descriptors: mut *mut u8,
	out_length: *mut usize) -> sys::zx_status_t,
	pub claim_interface: unsafe extern "C" fn (ctx: mut u8, intf: mut usb_interface_descriptor_t,
	length: usize) -> sys::zx_status_t,
	pub cancel_all: unsafe extern "C" fn (ctx: *mut u8, ep_address: u8) -> sys::zx_status_t,
	}

	#[repr(C)]
	pub struct usb_protocol_t {
	pub ops: *mut usb_protocol_ops_t,
	pub ctx: *mut u8,
	}

	impl Default for usb_protocol_t {
	fn default() -> Self {
	usb_protocol_t {
	ops: std::ptr::null_mut(),
	ctx: std::ptr::null_mut(),
	}
	}
	}

	#[link(name = "ddk")]
	extern "C" {
	pub static __zircon_driver_rec__: zx_driver_rec_t;

	pub fn device_add_from_driver(driver: mut zx_driver_t, parent: mut zx_device_t, args: mut device_add_args_t, out: mut *mut zx_device_t) -> sys::zx_status_t;
	pub fn device_remove(device: *mut zx_device_t) -> sys::zx_status_t;
	pub fn device_rebind(device: *mut zx_device_t) -> sys::zx_status_t;
	pub fn load_firmware(device: mut zx_device_t, path: const c_char, fw: mut sys::zx_handle_t, size: mut usize) -> sys::zx_status_t;
	pub fn device_get_name(dev: mut zx_device_t) -> const c_char;
	pub fn device_get_parent(dev: mut zx_device_t) -> mut zx_device_t;
	pub fn device_get_protocol(dev: mut zx_device_t, proto_id: u32, protocol: mut u8) -> sys::zx_status_t;
	pub fn device_read(dev: mut zx_device_t, buf: mut u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t;
	pub fn device_write(dev: mut zx_device_t, buf: const u8, count: usize, off: sys::zx_off_t, actual: *mut usize) -> sys::zx_status_t;
	pub fn device_get_size(dev: *mut zx_device_t) -> sys::zx_off_t;
	pub fn device_ioctl(dev: mut zx_device_t, op: u32, in_buf: const u8, in_len: usize, out_buf: mut u8, out_len: usize, out_actual: mut usize) -> sys::zx_status_t;
	pub fn device_state_clr_set(dev: *mut zx_device_t, clearflag: sys::zx_signals_t, setflag: sys::zx_signals_t);
	}