Reorganize psp definitions into one file

29 files changed, 5123 insertions, 5286 deletions

diff --git a/src/psp.rs b/src/psp.rs
new file mode 100644
index 0000000000..ef5edbce02
--- /dev/null
+++ b/src/psp.rs
@@ -0,0 +1,5123 @@
+//! PSP C type definitions
+//!
+//! These type declarations are not enough, as they must be ultimately resolved
+//! by the linker. Crates that use these definitions must, somewhere in the
+//! crate graph, include a stub provider crate such as the `psp` crate.
+
+pub type c_schar = i8;
+pub type c_uchar = u8;
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_float = f32;
+pub type c_double = f64;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type intptr_t = isize;
+pub type uintptr_t = usize;
+pub type ssize_t = isize;
+
+pub type c_char = u8;
+pub type c_long = i64;
+pub type c_ulong = u64;
+
+cfg_if! {
+    if #[cfg(libc_core_cvoid)] {
+        pub use ::ffi::c_void;
+    } else {
+        // Use repr(u8) as LLVM expects `void*` to be the same as `i8*` to help
+        // enable more optimization opportunities around it recognizing things
+        // like malloc/free.
+        #[repr(u8)]
+        #[allow(missing_copy_implementations)]
+        #[allow(missing_debug_implementations)]
+        pub enum c_void {
+            // Two dummy variants so the #[repr] attribute can be used.
+            #[doc(hidden)]
+            __variant1,
+            #[doc(hidden)]
+            __variant2,
+        }
+    }
+}
+
+pub type SceKernelVTimerHandler = unsafe extern "C" fn(
+    uid: SceUid,
+    arg1: *mut SceKernelSysClock,
+    arg2: *mut SceKernelSysClock,
+    arg3: *mut c_void,
+) -> u32;
+
+pub type SceKernelVTimerHandlerWide = unsafe extern "C" fn(
+    uid: SceUid,
+    arg1: i64,
+    arg2: i64,
+    arg3: *mut c_void,
+) -> u32;
+
+pub type SceKernelThreadEventHandler =
+    unsafe extern "C" fn(mask: i32, thid: SceUid, common: *mut c_void) -> i32;
+
+pub type SceKernelAlarmHandler =
+    unsafe extern "C" fn(common: *mut c_void) -> u32;
+
+pub type SceKernelCallbackFunction =
+    unsafe extern "C" fn(arg1: i32, arg2: i32, arg: *mut c_void) -> i32;
+
+pub type SceKernelThreadEntry =
+    unsafe extern "C" fn(args: usize, argp: *mut c_void) -> i32;
+
+pub type PowerCallback = extern "C" fn(unknown: i32, power_info: i32);
+
+pub type IoPermissions = i32;
+
+pub type UmdCallback = fn(unknown: i32, event: i32) -> i32;
+
+pub type SceMpegRingbufferCb = Option<
+    unsafe extern "C" fn(
+        data: *mut c_void,
+        num_packets: i32,
+        param: *mut c_void,
+    ) -> i32,
+>;
+
+pub type GuCallback = Option<extern "C" fn(id: i32, arg: *mut c_void)>;
+pub type GuSwapBuffersCallback =
+    Option<extern "C" fn(display: *mut *mut c_void, render: *mut *mut c_void)>;
+
+pub type SceNetAdhocctlHandler =
+    Option<unsafe extern "C" fn(flag: i32, error: i32, unknown: *mut c_void)>;
+
+pub type AdhocMatchingCallback = Option<
+    unsafe extern "C" fn(
+        matching_id: i32,
+        event: i32,
+        mac: *mut u8,
+        opt_len: i32,
+        opt_data: *mut c_void,
+    ),
+>;
+
+pub type SceNetApctlHandler = Option<
+    unsafe extern "C" fn(
+        oldState: i32,
+        newState: i32,
+        event: i32,
+        error: i32,
+        pArg: *mut c_void,
+    ),
+>;
+
+pub type HttpMallocFunction =
+    Option<unsafe extern "C" fn(size: usize) -> *mut c_void>;
+pub type HttpReallocFunction =
+    Option<unsafe extern "C" fn(p: *mut c_void, size: usize) -> *mut c_void>;
+pub type HttpFreeFunction = Option<unsafe extern "C" fn(p: *mut c_void)>;
+pub type HttpPasswordCB = Option<
+    unsafe extern "C" fn(
+        request: i32,
+        auth_type: HttpAuthType,
+        realm: *const u8,
+        username: *mut u8,
+        password: *mut u8,
+        need_entity: i32,
+        entity_body: *mut *mut u8,
+        entity_size: *mut usize,
+        save: *mut i32,
+    ) -> i32,
+>;
+
+#[allow(non_camel_case_types)]
+pub type socklen_t = u32;
+
+pub const INT_MIN: c_int = -2147483648;
+pub const INT_MAX: c_int = 2147483647;
+
+pub const AUDIO_VOLUME_MAX: u32 = 0x8000;
+pub const AUDIO_CHANNEL_MAX: u32 = 8;
+pub const AUDIO_NEXT_CHANNEL: i32 = -1;
+pub const AUDIO_SAMPLE_MIN: u32 = 64;
+pub const AUDIO_SAMPLE_MAX: u32 = 65472;
+
+pub const PSP_CTRL_SELECT: i32 = 0x000001;
+pub const PSP_CTRL_START: i32 = 0x000008;
+pub const PSP_CTRL_UP: i32 = 0x000010;
+pub const PSP_CTRL_RIGHT: i32 = 0x000020;
+pub const PSP_CTRL_DOWN: i32 = 0x000040;
+pub const PSP_CTRL_LEFT: i32 = 0x000080;
+pub const PSP_CTRL_LTRIGGER: i32 = 0x000100;
+pub const PSP_CTRL_RTRIGGER: i32 = 0x000200;
+pub const PSP_CTRL_TRIANGLE: i32 = 0x001000;
+pub const PSP_CTRL_CIRCLE: i32 = 0x002000;
+pub const PSP_CTRL_CROSS: i32 = 0x004000;
+pub const PSP_CTRL_SQUARE: i32 = 0x008000;
+pub const PSP_CTRL_HOME: i32 = 0x010000;
+pub const PSP_CTRL_HOLD: i32 = 0x020000;
+pub const PSP_CTRL_NOTE: i32 = 0x800000;
+pub const PSP_CTRL_SCREEN: i32 = 0x400000;
+pub const PSP_CTRL_VOLUP: i32 = 0x100000;
+pub const PSP_CTRL_VOLDOWN: i32 = 0x200000;
+pub const PSP_CTRL_WLAN_UP: i32 = 0x040000;
+pub const PSP_CTRL_REMOTE: i32 = 0x080000;
+pub const PSP_CTRL_DISC: i32 = 0x1000000;
+pub const PSP_CTRL_MS: i32 = 0x2000000;
+
+pub const USB_CAM_PID: i32 = 0x282;
+pub const USB_BUS_DRIVER_NAME: &str = "USBBusDriver";
+pub const USB_CAM_DRIVER_NAME: &str = "USBCamDriver";
+pub const USB_CAM_MIC_DRIVER_NAME: &str = "USBCamMicDriver";
+pub const USB_STOR_DRIVER_NAME: &str = "USBStor_Driver";
+
+pub const ACTIVATED: i32 = 0x200;
+pub const CONNECTED: i32 = 0x020;
+pub const ESTABLISHED: i32 = 0x002;
+
+pub const USB_CAM_FLIP: i32 = 1;
+pub const USB_CAM_MIRROR: i32 = 0x100;
+
+pub const THREAD_ATTR_VFPU: i32 = 0x00004000;
+pub const THREAD_ATTR_USER: i32 = 0x80000000;
+pub const THREAD_ATTR_USBWLAN: i32 = 0xa0000000;
+pub const THREAD_ATTR_VSH: i32 = 0xc0000000;
+pub const THREAD_ATTR_SCRATCH_SRAM: i32 = 0x00008000;
+pub const THREAD_ATTR_NO_FILLSTACK: i32 = 0x00100000;
+pub const THREAD_ATTR_CLEAR_STACK: i32 = 0x00200000;
+
+pub const EVENT_WAIT_MULTIPLE: i32 = 0x200;
+
+pub const EVENT_WAIT_AND: i32 = 0;
+pub const EVENT_WAIT_OR: i32 = 1;
+pub const EVENT_WAIT_CLEAR: i32 = 0x20;
+
+pub const POWER_INFO_POWER_SWITCH: i32 = 0x80000000;
+pub const POWER_INFO_HOLD_SWITCH: i32 = 0x40000000;
+pub const POWER_INFO_STANDBY: i32 = 0x00080000;
+pub const POWER_INFO_RESUME_COMPLETE: i32 = 0x00040000;
+pub const POWER_INFO_RESUMING: i32 = 0x00020000;
+pub const POWER_INFO_SUSPENDING: i32 = 0x00010000;
+pub const POWER_INFO_AC_POWER: i32 = 0x00001000;
+pub const POWER_INFO_BATTERY_LOW: i32 = 0x00000100;
+pub const POWER_INFO_BATTERY_EXIST: i32 = 0x00000080;
+pub const POWER_INFO_BATTERY_POWER: i32 = 0x0000007;
+
+pub const FIO_S_IFLNK: i32 = 0x4000;
+pub const FIO_S_IFDIR: i32 = 0x1000;
+pub const FIO_S_IFREG: i32 = 0x2000;
+pub const FIO_S_ISUID: i32 = 0x0800;
+pub const FIO_S_ISGID: i32 = 0x0400;
+pub const FIO_S_ISVTX: i32 = 0x0200;
+pub const FIO_S_IRUSR: i32 = 0x0100;
+pub const FIO_S_IWUSR: i32 = 0x0080;
+pub const FIO_S_IXUSR: i32 = 0x0040;
+pub const FIO_S_IRGRP: i32 = 0x0020;
+pub const FIO_S_IWGRP: i32 = 0x0010;
+pub const FIO_S_IXGRP: i32 = 0x0008;
+pub const FIO_S_IROTH: i32 = 0x0004;
+pub const FIO_S_IWOTH: i32 = 0x0002;
+pub const FIO_S_IXOTH: i32 = 0x0001;
+
+pub const FIO_SO_IFLNK: i32 = 0x0008;
+pub const FIO_SO_IFDIR: i32 = 0x0010;
+pub const FIO_SO_IFREG: i32 = 0x0020;
+pub const FIO_SO_IROTH: i32 = 0x0004;
+pub const FIO_SO_IWOTH: i32 = 0x0002;
+pub const FIO_SO_IXOTH: i32 = 0x0001;
+
+pub const PSP_O_RD_ONLY: i32 = 0x0001;
+pub const PSP_O_WR_ONLY: i32 = 0x0002;
+pub const PSP_O_RD_WR: i32 = 0x0003;
+pub const PSP_O_NBLOCK: i32 = 0x0004;
+pub const PSP_O_DIR: i32 = 0x0008;
+pub const PSP_O_APPEND: i32 = 0x0100;
+pub const PSP_O_CREAT: i32 = 0x0200;
+pub const PSP_O_TRUNC: i32 = 0x0400;
+pub const PSP_O_EXCL: i32 = 0x0800;
+pub const PSP_O_NO_WAIT: i32 = 0x8000;
+
+pub const UMD_NOT_PRESENT: i32 = 0x01;
+pub const UMD_PRESENT: i32 = 0x02;
+pub const UMD_CHANGED: i32 = 0x04;
+pub const UMD_INITING: i32 = 0x08;
+pub const UMD_INITED: i32 = 0x10;
+pub const UMD_READY: i32 = 0x20;
+
+pub const PLAY_PAUSE: i32 = 0x1;
+pub const FORWARD: i32 = 0x4;
+pub const BACK: i32 = 0x8;
+pub const VOL_UP: i32 = 0x10;
+pub const VOL_DOWN: i32 = 0x20;
+pub const HOLD: i32 = 0x80;
+
+pub const GU_PI: f32 = 3.141593;
+
+pub const GU_TEXTURE_8BIT: i32 = 1;
+pub const GU_TEXTURE_16BIT: i32 = 2;
+pub const GU_TEXTURE_32BITF: i32 = 3;
+pub const GU_COLOR_5650: i32 = 4 << 2;
+pub const GU_COLOR_5551: i32 = 5 << 2;
+pub const GU_COLOR_4444: i32 = 6 << 2;
+pub const GU_COLOR_8888: i32 = 7 << 2;
+pub const GU_NORMAL_8BIT: i32 = 1 << 5;
+pub const GU_NORMAL_16BIT: i32 = 2 << 5;
+pub const GU_NORMAL_32BITF: i32 = 3 << 5;
+pub const GU_VERTEX_8BIT: i32 = 1 << 7;
+pub const GU_VERTEX_16BIT: i32 = 2 << 7;
+pub const GU_VERTEX_32BITF: i32 = 3 << 7;
+pub const GU_WEIGHT_8BIT: i32 = 1 << 9;
+pub const GU_WEIGHT_16BIT: i32 = 2 << 9;
+pub const GU_WEIGHT_32BITF: i32 = 3 << 9;
+pub const GU_INDEX_8BIT: i32 = 1 << 11;
+pub const GU_INDEX_16BIT: i32 = 2 << 11;
+pub const GU_WEIGHTS1: i32 = num_weights(1);
+pub const GU_WEIGHTS2: i32 = num_weights(2);
+pub const GU_WEIGHTS3: i32 = num_weights(3);
+pub const GU_WEIGHTS4: i32 = num_weights(4);
+pub const GU_WEIGHTS5: i32 = num_weights(5);
+pub const GU_WEIGHTS6: i32 = num_weights(6);
+pub const GU_WEIGHTS7: i32 = num_weights(7);
+pub const GU_WEIGHTS8: i32 = num_weights(8);
+pub const GU_VERTICES1: i32 = num_vertices(1);
+pub const GU_VERTICES2: i32 = num_vertices(2);
+pub const GU_VERTICES3: i32 = num_vertices(3);
+pub const GU_VERTICES4: i32 = num_vertices(4);
+pub const GU_VERTICES5: i32 = num_vertices(5);
+pub const GU_VERTICES6: i32 = num_vertices(6);
+pub const GU_VERTICES7: i32 = num_vertices(7);
+pub const GU_VERTICES8: i32 = num_vertices(8);
+pub const GU_TRANSFORM_2D: i32 = 1 << 23;
+pub const GU_TRANSFORM_3D: i32 = 0;
+
+const fn num_weights(n: u32) -> i32 {
+    (((n - 1) & 7) << 14) as i32
+}
+
+const fn num_vertices(n: u32) -> i32 {
+    (((n - 1) & 7) << 18) as i32
+}
+
+pub const GU_COLOR_BUFFER_BIT: i32 = 1;
+pub const GU_STENCIL_BUFFER_BIT: i32 = 2;
+pub const GU_DEPTH_BUFFER_BIT: i32 = 4;
+pub const GU_FAST_CLEAR_BIT: i32 = 16;
+
+pub const GU_AMBIENT: i32 = 1;
+pub const GU_DIFFUSE: i32 = 2;
+pub const GU_SPECULAR: i32 = 4;
+pub const GU_UNKNOWN_LIGHT_COMPONENT: i32 = 8;
+
+pub const SYSTEM_REGISTRY: [u8; 7] = *b"/system";
+pub const REG_KEYNAME_SIZE: u32 = 27;
+
+pub const UTILITY_MSGDIALOG_ERROR: i32 = 0;
+pub const UTILITY_MSGDIALOG_TEXT: i32 = 1;
+pub const UTILITY_MSGDIALOG_YES_NO_BUTTONS: i32 = 0x10;
+pub const UTILITY_MSGDIALOG_DEFAULT_NO: i32 = 0x100;
+
+pub const UTILITY_HTMLVIEWER_OPEN_SCE_START_PAGE: i32 = 0x000001;
+pub const UTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITS: i32 = 0x000002;
+pub const UTILITY_HTMLVIEWER_DISABLE_EXIT_DIALOG: i32 = 0x000004;
+pub const UTILITY_HTMLVIEWER_DISABLE_CURSOR: i32 = 0x000008;
+pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_COMPLETE_DIALOG: i32 = 0x000010;
+pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_START_DIALOG: i32 = 0x000020;
+pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_DESTINATION_DIALOG: i32 =
+    0x000040;
+pub const UTILITY_HTMLVIEWER_LOCK_DOWNLOAD_DESTINATION_DIALOG: i32 = 0x000080;
+pub const UTILITY_HTMLVIEWER_DISABLE_TAB_DISPLAY: i32 = 0x000100;
+pub const UTILITY_HTMLVIEWER_ENABLE_ANALOG_HOLD: i32 = 0x000200;
+pub const UTILITY_HTMLVIEWER_ENABLE_FLASH: i32 = 0x000400;
+pub const UTILITY_HTMLVIEWER_DISABLE_LRTRIGGER: i32 = 0x000800;
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum AudioFormat {
+    Stereo = 0,
+    Mono = 0x10,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct AudioInputParams {
+    pub unknown1: i32,
+    pub gain: i32,
+    pub unknown2: i32,
+    pub unknown3: i32,
+    pub unknown4: i32,
+    pub unknown5: i32,
+}
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum AudioOutputFrequency {
+    Khz48 = 48000,
+    Khz44_1 = 44100,
+    Khz32 = 32000,
+    Khz24 = 24000,
+    Khz22_05 = 22050,
+    Khz16 = 16000,
+    Khz12 = 12000,
+    Khz11_025 = 11025,
+    Khz8 = 8000,
+}
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum AudioInputFrequency {
+    Khz44_1 = 44100,
+    Khz22_05 = 22050,
+    Khz11_025 = 11025,
+}
+
+extern "C" {
+    pub fn sceAudioChReserve(
+        channel: i32,
+        sample_count: i32,
+        format: AudioFormat,
+    ) -> i32;
+    pub fn sceAudioChRelease(channel: i32) -> i32;
+    pub fn sceAudioOutput(channel: i32, vol: i32, buf: *mut c_void) -> i32;
+    pub fn sceAudioOutputBlocking(
+        channel: i32,
+        vol: i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceAudioOutputPanned(
+        channel: i32,
+        left_vol: i32,
+        right_vol: i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceAudioOutputPannedBlocking(
+        channel: i32,
+        left_vol: i32,
+        right_vol: i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceAudioGetChannelRestLen(channel: i32) -> i32;
+    pub fn sceAudioGetChannelRestLength(channel: i32) -> i32;
+    pub fn sceAudioSetChannelDataLen(channel: i32, sample_count: i32) -> i32;
+    pub fn sceAudioChangeChannelConfig(
+        channel: i32,
+        format: AudioFormat,
+    ) -> i32;
+    pub fn sceAudioChangeChannelVolume(
+        channel: i32,
+        left_vol: i32,
+        right_vol: i32,
+    ) -> i32;
+    pub fn sceAudioOutput2Reserve(sample_count: i32) -> i32;
+    pub fn sceAudioOutput2Release() -> i32;
+    pub fn sceAudioOutput2ChangeLength(sample_count: i32) -> i32;
+    pub fn sceAudioOutput2OutputBlocking(vol: i32, buf: *mut c_void) -> i32;
+    pub fn sceAudioOutput2GetRestSample() -> i32;
+    pub fn sceAudioSRCChReserve(
+        sample_count: i32,
+        freq: AudioOutputFrequency,
+        channels: i32,
+    ) -> i32;
+    pub fn sceAudioSRCChRelease() -> i32;
+    pub fn sceAudioSRCOutputBlocking(vol: i32, buf: *mut c_void) -> i32;
+    pub fn sceAudioInputInit(unknown1: i32, gain: i32, unknown2: i32) -> i32;
+    pub fn sceAudioInputInitEx(params: *mut AudioInputParams) -> i32;
+    pub fn sceAudioInputBlocking(
+        sample_count: i32,
+        freq: AudioInputFrequency,
+        buf: *mut c_void,
+    );
+    pub fn sceAudioInput(
+        sample_count: i32,
+        freq: AudioInputFrequency,
+        buf: *mut c_void,
+    );
+    pub fn sceAudioGetInputLength() -> i32;
+    pub fn sceAudioWaitInputEnd() -> i32;
+    pub fn sceAudioPollInputEnd() -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Atrac3BufferInfo {
+    pub puc_write_position_first_buf: *mut u8,
+    pub ui_writable_byte_first_buf: u32,
+    pub ui_min_write_byte_first_buf: u32,
+    pub ui_read_position_first_buf: u32,
+    pub puc_write_position_second_buf: *mut u8,
+    pub ui_writable_byte_second_buf: u32,
+    pub ui_min_write_byte_second_buf: u32,
+    pub ui_read_position_second_buf: u32,
+}
+
+extern "C" {
+    pub fn sceAtracGetAtracID(ui_codec_type: u32) -> i32;
+    pub fn sceAtracSetDataAndGetID(
+        buf: *mut c_void,
+        bufsize: usize,
+    ) -> i32;
+    pub fn sceAtracDecodeData(
+        atrac_id: i32,
+        out_samples: *mut u16,
+        out_n: *mut i32,
+        out_end: *mut i32,
+        out_remain_frame: *mut i32,
+    ) -> i32;
+    pub fn sceAtracGetRemainFrame(
+        atrac_id: i32,
+        out_remain_frame: *mut i32,
+    ) -> i32;
+    pub fn sceAtracGetStreamDataInfo(
+        atrac_id: i32,
+        write_pointer: *mut *mut u8,
+        available_bytes: *mut u32,
+        read_offset: *mut u32,
+    ) -> i32;
+    pub fn sceAtracAddStreamData(
+        atrac_id: i32,
+        bytes_to_add: u32,
+    ) -> i32;
+    pub fn sceAtracGetBitrate(
+        atrac_id: i32,
+        out_bitrate: *mut i32,
+    ) -> i32;
+    pub fn sceAtracSetLoopNum(
+        atrac_id: i32,
+        nloops: i32,
+    ) -> i32;
+    pub fn sceAtracReleaseAtracID(atrac_id: i32) -> i32;
+    pub fn sceAtracGetNextSample(
+        atrac_id: i32,
+        out_n: *mut i32,
+    ) -> i32;
+    pub fn sceAtracGetMaxSample(
+        atrac_id: i32,
+        out_max: *mut i32,
+    ) -> i32;
+    pub fn sceAtracGetBufferInfoForReseting(
+        atrac_id: i32,
+        ui_sample: u32,
+        pbuffer_info: *mut Atrac3BufferInfo,
+    ) -> i32;
+    pub fn sceAtracGetChannel(
+        atrac_id: i32,
+        pui_channel: *mut u32,
+    ) -> i32;
+    pub fn sceAtracGetInternalErrorInfo(
+        atrac_id: i32,
+        pi_result: *mut i32,
+    ) -> i32;
+    pub fn sceAtracGetLoopStatus(
+        atrac_id: i32,
+        pi_loop_num: *mut i32,
+        pui_loop_status: *mut u32,
+    ) -> i32;
+    pub fn sceAtracGetNextDecodePosition(
+        atrac_id: i32,
+        pui_sample_position: *mut u32,
+    ) -> i32;
+    pub fn sceAtracGetSecondBufferInfo(
+        atrac_id: i32,
+        pui_position: *mut u32,
+        pui_data_byte: *mut u32,
+    ) -> i32;
+    pub fn sceAtracGetSoundSample(
+        atrac_id: i32,
+        pi_end_sample: *mut i32,
+        pi_loop_start_sample: *mut i32,
+        pi_loop_end_sample: *mut i32,
+    ) -> i32;
+    pub fn sceAtracResetPlayPosition(
+        atrac_id: i32,
+        ui_sample: u32,
+        ui_write_byte_first_buf: u32,
+        ui_write_byte_second_buf: u32,
+    ) -> i32;
+    pub fn sceAtracSetData(
+        atrac_id: i32,
+        puc_buffer_addr: *mut u8,
+        ui_buffer_byte: u32,
+    ) -> i32;
+    pub fn sceAtracSetHalfwayBuffer(
+        atrac_id: i32,
+        puc_buffer_addr: *mut u8,
+        ui_read_byte: u32,
+        ui_buffer_byte: u32,
+    ) -> i32;
+    pub fn sceAtracSetHalfwayBufferAndGetID(
+        puc_buffer_addr: *mut u8,
+        ui_read_byte: u32,
+        ui_buffer_byte: u32,
+    ) -> i32;
+    pub fn sceAtracSetSecondBuffer(
+        atrac_id: i32,
+        puc_second_buffer_addr: *mut u8,
+        ui_second_buffer_byte: u32,
+    ) -> i32;
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum CtrlMode {
+    Digital = 0,
+    Analaog,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct SceCtrlData {
+    pub timestamp: u32,
+    pub buttons: i32,
+    pub lx: u8,
+    pub ly: u8,
+    pub rsrv: [u8; 6],
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct SceCtrlLatch {
+    pub ui_make: u32,
+    pub ui_break: u32,
+    pub ui_press: u32,
+    pub ui_release: u32,
+}
+
+extern "C" {
+    pub fn sceCtrlSetSamplingCycle(cycle: i32) -> i32;
+    pub fn sceCtrlGetSamplingCycle(pcycle: *mut i32) -> i32;
+    pub fn sceCtrlSetSamplingMode(mode: CtrlMode) -> i32;
+    pub fn sceCtrlGetSamplingMode(pmode: *mut i32) -> i32;
+    pub fn sceCtrlPeekBufferPositive(
+        pad_data: *mut SceCtrlData,
+        count: i32,
+    ) -> i32;
+    pub fn sceCtrlPeekBufferNegative(
+        pad_data: *mut SceCtrlData,
+        count: i32,
+    ) -> i32;
+    pub fn sceCtrlReadBufferPositive(
+        pad_data: *mut SceCtrlData,
+        count: i32,
+    ) -> i32;
+    pub fn sceCtrlReadBufferNegative(
+        pad_data: *mut SceCtrlData,
+        count: i32,
+    ) -> i32;
+    pub fn sceCtrlPeekLatch(latch_data: *mut SceCtrlLatch) -> i32;
+    pub fn sceCtrlReadLatch(latch_data: *mut SceCtrlLatch) -> i32;
+    pub fn sceCtrlSetIdleCancelThreshold(idlereset: i32, idleback: i32)
+        -> i32;
+    pub fn sceCtrlGetIdleCancelThreshold(
+        idlereset: *mut i32,
+        idleback: *mut i32,
+    ) -> i32;
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum DisplayMode {
+    Lcd = 0,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum DisplayPixelFormat {
+    Psm5650 = 0,
+    Psm5551 = 1,
+    Psm4444 = 2,
+    Psm8888 = 3,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum DisplaySetBufSync {
+    Immediate = 0,
+    NextFrame = 1,
+}
+
+extern "C" {
+    pub fn sceDisplaySetMode(
+        mode: DisplayMode,
+        width: usize,
+        height: usize,
+    ) -> u32;
+    pub fn sceDisplayGetMode(
+        pmode: *mut i32,
+        pwidth: *mut i32,
+        pheight: *mut i32,
+    ) -> i32;
+    pub fn sceDisplaySetFrameBuf(
+        top_addr: *const u8,
+        buffer_width: usize,
+        pixel_format: DisplayPixelFormat,
+        sync: DisplaySetBufSync,
+    ) -> u32;
+    pub fn sceDisplayGetFrameBuf(
+        top_addr: *mut *mut c_void,
+        buffer_width: *mut usize,
+        pixel_format: *mut DisplayPixelFormat,
+        sync: DisplaySetBufSync,
+    ) -> i32;
+    pub fn sceDisplayGetVcount() -> u32;
+    pub fn sceDisplayWaitVblank() -> i32;
+    pub fn sceDisplayWaitVblankCB() -> i32;
+    pub fn sceDisplayWaitVblankStart() -> i32;
+    pub fn sceDisplayWaitVblankStartCB() -> i32;
+    pub fn sceDisplayGetAccumulatedHcount() -> i32;
+    pub fn sceDisplayGetCurrentHcount() -> i32;
+    pub fn sceDisplayGetFramePerSec() -> f32;
+    pub fn sceDisplayIsForeground() -> i32;
+    pub fn sceDisplayIsVblank() -> i32;
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct GeContext {
+    pub context: [u32; 512],
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct GeStack {
+    pub stack: [u32; 8],
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct GeCallbackData {
+    pub signal_func: Option<extern "C" fn(id: i32, arg: *mut c_void)>,
+    pub signal_arg: *mut c_void,
+    pub finish_func: Option<extern "C" fn(id: i32, arg: *mut c_void)>,
+    pub finish_arg: *mut c_void,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct GeListArgs {
+    pub size: u32,
+    pub context: *mut GeContext,
+    pub num_stacks: u32,
+    pub stacks: *mut GeStack,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct GeBreakParam {
+    pub buf: [u32; 4],
+}
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum GeMatrixType {
+    Bone0 = 0,
+    Bone1,
+    Bone2,
+    Bone3,
+    Bone4,
+    Bone5,
+    Bone6,
+    Bone7,
+    World,
+    View,
+    Projection,
+    TexGen,
+}
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum GeListState {
+    Done = 0,
+    Queued,
+    DrawingDone,
+    StallReached,
+    CancelDone,
+}
+
+#[repr(u8)]
+#[derive(Copy, Clone)]
+pub enum GeCommand {
+    Nop = 0,
+    Vaddr = 0x1,
+    Iaddr = 0x2,
+    Prim = 0x4,
+    Bezier = 0x5,
+    Spline = 0x6,
+    BoundingBox = 0x7,
+    Jump = 0x8,
+    BJump = 0x9,
+    Call = 0xa,
+    Ret = 0xb,
+    End = 0xc,
+    Signal = 0xe,
+    Finish = 0xf,
+    Base = 0x10,
+    VertexType = 0x12,
+    OffsetAddr = 0x13,
+    Origin = 0x14,
+    Region1 = 0x15,
+    Region2 = 0x16,
+    LightingEnable = 0x17,
+    LightEnable0 = 0x18,
+    LightEnable1 = 0x19,
+    LightEnable2 = 0x1a,
+    LightEnable3 = 0x1b,
+    DepthClampEnable = 0x1c,
+    CullFaceEnable = 0x1d,
+    TextureMapEnable = 0x1e,
+    FogEnable = 0x1f,
+    DitherEnable = 0x20,
+    AlphaBlendEnable = 0x21,
+    AlphaTestEnable = 0x22,
+    ZTestEnable = 0x23,
+    StencilTestEnable = 0x24,
+    AntiAliasEnable = 0x25,
+    PatchCullEnable = 0x26,
+    ColorTestEnable = 0x27,
+    LogicOpEnable = 0x28,
+    BoneMatrixNumber = 0x2a,
+    BoneMatrixData = 0x2b,
+    MorphWeight0 = 0x2c,
+    MorphWeight1 = 0x2d,
+    MorphWeight2 = 0x2e,
+    MorphWeight3 = 0x2f,
+    MorphWeight4 = 0x30,
+    MorphWeight5 = 0x31,
+    MorphWeight6 = 0x32,
+    MorphWeight7 = 0x33,
+    PatchDivision = 0x36,
+    PatchPrimitive = 0x37,
+    PatchFacing = 0x38,
+    WorldMatrixNumber = 0x3a,
+    WorldMatrixData = 0x3b,
+    ViewMatrixNumber = 0x3c,
+    ViewMatrixData = 0x3d,
+    ProjMatrixNumber = 0x3e,
+    ProjMatrixData = 0x3f,
+    TGenMatrixNumber = 0x40,
+    TGenMatrixData = 0x41,
+    ViewportXScale = 0x42,
+    ViewportYScale = 0x43,
+    ViewportZScale = 0x44,
+    ViewportXCenter = 0x45,
+    ViewportYCenter = 0x46,
+    ViewportZCenter = 0x47,
+    TexScaleU = 0x48,
+    TexScaleV = 0x49,
+    TexOffsetU = 0x4a,
+    TexOffsetV = 0x4b,
+    OffsetX = 0x4c,
+    OffsetY = 0x4d,
+    ShadeMode = 0x50,
+    ReverseNormal = 0x51,
+    MaterialUpdate = 0x53,
+    MaterialEmissive = 0x54,
+    MaterialAmbient = 0x55,
+    MaterialDiffuse = 0x56,
+    MaterialSpecular = 0x57,
+    MaterialAlpha = 0x58,
+    MaterialSpecularCoef = 0x5b,
+    AmbientColor = 0x5c,
+    AmbientAlpha = 0x5d,
+    LightMode = 0x5e,
+    LightType0 = 0x5f,
+    LightType1 = 0x60,
+    LightType2 = 0x61,
+    LightType3 = 0x62,
+    Light0X = 0x63,
+    Light0Y,
+    Light0Z,
+    Light1X,
+    Light1Y,
+    Light1Z,
+    Light2X,
+    Light2Y,
+    Light2Z,
+    Light3X,
+    Light3Y,
+    Light3Z,
+    Light0DirectionX = 0x6f,
+    Light0DirectionY,
+    Light0DirectionZ,
+    Light1DirectionX,
+    Light1DirectionY,
+    Light1DirectionZ,
+    Light2DirectionX,
+    Light2DirectionY,
+    Light2DirectionZ,
+    Light3DirectionX,
+    Light3DirectionY,
+    Light3DirectionZ,
+    Light0ConstantAtten = 0x7b,
+    Light0LinearAtten,
+    Light0QuadtraticAtten,
+    Light1ConstantAtten,
+    Light1LinearAtten,
+    Light1QuadtraticAtten,
+    Light2ConstantAtten,
+    Light2LinearAtten,
+    Light2QuadtraticAtten,
+    Light3ConstantAtten,
+    Light3LinearAtten,
+    Light3QuadtraticAtten,
+    Light0ExponentAtten = 0x87,
+    Light1ExponentAtten,
+    Light2ExponentAtten,
+    Light3ExponentAtten,
+    Light0CutoffAtten = 0x8b,
+    Light1CutoffAtten,
+    Light2CutoffAtten,
+    Light3CutoffAtten,
+    Light0Ambient = 0x8f,
+    Light0Diffuse,
+    Light0Specular,
+    Light1Ambient,
+    Light1Diffuse,
+    Light1Specular,
+    Light2Ambient,
+    Light2Diffuse,
+    Light2Specular,
+    Light3Ambient,
+    Light3Diffuse,
+    Light3Specular,
+    Cull = 0x9b,
+    FrameBufPtr = 0x9c,
+    FrameBufWidth = 0x9d,
+    ZBufPtr = 0x9e,
+    ZBufWidth = 0x9f,
+    TexAddr0 = 0xa0,
+    TexAddr1,
+    TexAddr2,
+    TexAddr3,
+    TexAddr4,
+    TexAddr5,
+    TexAddr6,
+    TexAddr7,
+    TexBufWidth0 = 0xa8,
+    TexBufWidth1,
+    TexBufWidth2,
+    TexBufWidth3,
+    TexBufWidth4,
+    TexBufWidth5,
+    TexBufWidth6,
+    TexBufWidth7,
+    ClutAddr = 0xb0,
+    ClutAddrUpper = 0xb1,
+    TransferSrc,
+    TransferSrcW,
+    TransferDst,
+    TransferDstW,
+    TexSize0 = 0xb8,
+    TexSize1,
+    TexSize2,
+    TexSize3,
+    TexSize4,
+    TexSize5,
+    TexSize6,
+    TexSize7,
+    TexMapMode = 0xc0,
+    TexShadeLs = 0xc1,
+    TexMode = 0xc2,
+    TexFormat = 0xc3,
+    LoadClut = 0xc4,
+    ClutFormat = 0xc5,
+    TexFilter = 0xc6,
+    TexWrap = 0xc7,
+    TexLevel = 0xc8,
+    TexFunc = 0xc9,
+    TexEnvColor = 0xca,
+    TexFlush = 0xcb,
+    TexSync = 0xcc,
+    Fog1 = 0xcd,
+    Fog2 = 0xce,
+    FogColor = 0xcf,
+    TexLodSlope = 0xd0,
+    FramebufPixFormat = 0xd2,
+    ClearMode = 0xd3,
+    Scissor1 = 0xd4,
+    Scissor2 = 0xd5,
+    MinZ = 0xd6,
+    MaxZ = 0xd7,
+    ColorTest = 0xd8,
+    ColorRef = 0xd9,
+    ColorTestmask = 0xda,
+    AlphaTest = 0xdb,
+    StencilTest = 0xdc,
+    StencilOp = 0xdd,
+    ZTest = 0xde,
+    BlendMode = 0xdf,
+    BlendFixedA = 0xe0,
+    BlendFixedB = 0xe1,
+    Dith0 = 0xe2,
+    Dith1,
+    Dith2,
+    Dith3,
+    LogicOp = 0xe6,
+    ZWriteDisable = 0xe7,
+    MaskRgb = 0xe8,
+    MaskAlpha = 0xe9,
+    TransferStart = 0xea,
+    TransferSrcPos = 0xeb,
+    TransferDstPos = 0xec,
+    TransferSize = 0xee,
+    Vscx = 0xf0,
+    Vscy = 0xf1,
+    Vscz = 0xf2,
+    Vtcs = 0xf3,
+    Vtct = 0xf4,
+    Vtcq = 0xf5,
+    Vcv = 0xf6,
+    Vap = 0xf7,
+    Vfc = 0xf8,
+    Vscv = 0xf9,
+
+    Unknown03 = 0x03,
+    Unknown0D = 0x0d,
+    Unknown11 = 0x11,
+    Unknown29 = 0x29,
+    Unknown34 = 0x34,
+    Unknown35 = 0x35,
+    Unknown39 = 0x39,
+    Unknown4E = 0x4e,
+    Unknown4F = 0x4f,
+    Unknown52 = 0x52,
+    Unknown59 = 0x59,
+    Unknown5A = 0x5a,
+    UnknownB6 = 0xb6,
+    UnknownB7 = 0xb7,
+    UnknownD1 = 0xd1,
+    UnknownED = 0xed,
+    UnknownEF = 0xef,
+    UnknownFA = 0xfa,
+    UnknownFB = 0xfb,
+    UnknownFC = 0xfc,
+    UnknownFD = 0xfd,
+    UnknownFE = 0xfe,
+    NopFF = 0xff,
+}
+
+extern "C" {
+    pub fn sceGeEdramGetSize() -> u32;
+    pub fn sceGeEdramGetAddr() -> *mut u8;
+    pub fn sceGeEdramSetAddrTranslation(width: i32) -> i32;
+    pub fn sceGeGetCmd(cmd: i32) -> u32;
+    pub fn sceGeGetMtx(type_: GeMatrixType, matrix: *mut c_void) -> i32;
+    pub fn sceGeGetStack(stack_id: i32, stack: *mut GeStack) -> i32;
+    pub fn sceGeSaveContext(context: *mut GeContext) -> i32;
+    pub fn sceGeRestoreContext(context: *const GeContext) -> i32;
+    pub fn sceGeListEnQueue(
+        list: *const c_void,
+        stall: *mut c_void,
+        cbid: i32,
+        arg: *mut GeListArgs,
+    ) -> i32;
+    pub fn sceGeListEnQueueHead(
+        list: *const c_void,
+        stall: *mut c_void,
+        cbid: i32,
+        arg: *mut GeListArgs,
+    ) -> i32;
+    pub fn sceGeListDeQueue(qid: i32) -> i32;
+    pub fn sceGeListUpdateStallAddr(qid: i32, stall: *mut c_void) -> i32;
+    pub fn sceGeListSync(qid: i32, sync_type: i32) -> GeListState;
+    pub fn sceGeDrawSync(sync_type: i32) -> GeListState;
+    pub fn sceGeBreak(mode: i32, p_param: *mut GeBreakParam) -> i32;
+    pub fn sceGeContinue() -> i32;
+    pub fn sceGeSetCallback(cb: *mut GeCallbackData) -> i32;
+    pub fn sceGeUnsetCallback(cbid: i32) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelLoadExecParam {
+    pub size: usize,
+    pub args: usize,
+    pub argp: *mut c_void,
+    pub key: *const u8,
+}
+
+extern "C" {
+    pub fn sceKernelExitGame();
+    pub fn sceKernelRegisterExitCallback(id: SceUid) -> i32;
+    pub fn sceKernelLoadExec(
+        file: *const u8,
+        param: *mut SceKernelLoadExecParam,
+    ) -> i32;
+}
+
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct SceUid(pub i32);
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum SceSysMemPartitionId {
+    SceKernelUnknownPartition = 0,
+    SceKernelPrimaryKernelPartition = 1,
+    SceKernelPrimaryUserPartition = 2,
+    SceKernelOtherKernelPartition1 = 3,
+    SceKernelOtherKernelPartition2 = 4,
+    SceKernelVshellPARTITION = 5,
+    SceKernelScUserPartition = 6,
+    SceKernelMeUserPartition = 7,
+    SceKernelExtendedScKernelPartition = 8,
+    SceKernelExtendedSc2KernelPartition = 9,
+    SceKernelExtendedMeKernelPartition = 10,
+    SceKernelVshellKernelPartition = 11,
+    SceKernelExtendedKernelPartition = 12,
+}
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum SceSysMemBlockTypes {
+    Low = 0,
+    High,
+    Addr,
+}
+
+extern "C" {
+    pub fn sceKernelAllocPartitionMemory(
+        partition: SceSysMemPartitionId,
+        name: *const u8,
+        type_: SceSysMemBlockTypes,
+        size: u32,
+        addr: *mut c_void,
+    ) -> SceUid;
+    pub fn sceKernelGetBlockHeadAddr(blockid: SceUid) -> *mut c_void;
+    pub fn sceKernelFreePartitionMemory(blockid: SceUid) -> i32;
+    pub fn sceKernelTotalFreeMemSize() -> usize;
+    pub fn sceKernelMaxFreeMemSize() -> usize;
+    pub fn sceKernelDevkitVersion() -> u32;
+    pub fn sceKernelSetCompiledSdkVersion(version: u32) -> i32;
+    pub fn sceKernelGetCompiledSdkVersion() -> u32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct timeval {
+    pub tv_sec: i32,
+    pub tv_usec: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct timezone {
+    pub tz_minutes_west: i32,
+    pub tz_dst_time: i32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelUtilsSha1Context {
+    pub h: [u32; 5usize],
+    pub us_remains: u16,
+    pub us_computed: u16,
+    pub ull_total_len: u64,
+    pub buf: [u8; 64usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelUtilsMt19937Context {
+    pub count: u32,
+    pub state: [u32; 624usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelUtilsMd5Context {
+    pub h: [u32; 4usize],
+    pub pad: u32,
+    pub us_remains: u16,
+    pub us_computed: u16,
+    pub ull_total_len: u64,
+    pub buf: [u8; 64usize],
+}
+
+extern "C" {
+    pub fn sceKernelLibcTime(t: *mut i32) -> i32;
+    pub fn sceKernelLibcClock() -> u32;
+    pub fn sceKernelLibcGettimeofday(
+        tp: *mut timeval,
+        tzp: *mut timezone,
+    ) -> i32;
+    pub fn sceKernelDcacheWritebackAll();
+    pub fn sceKernelDcacheWritebackInvalidateAll();
+    pub fn sceKernelDcacheWritebackRange(p: *const c_void, size: u32);
+    pub fn sceKernelDcacheWritebackInvalidateRange(
+        p: *const c_void,
+        size: u32,
+    );
+    pub fn sceKernelDcacheInvalidateRange(p: *const c_void, size: u32);
+    pub fn sceKernelIcacheInvalidateAll();
+    pub fn sceKernelIcacheInvalidateRange(p: *const c_void, size: u32);
+    pub fn sceKernelUtilsMt19937Init(
+        ctx: *mut SceKernelUtilsMt19937Context,
+        seed: u32,
+    ) -> i32;
+    pub fn sceKernelUtilsMt19937UInt(
+        ctx: *mut SceKernelUtilsMt19937Context,
+    ) -> u32;
+    pub fn sceKernelUtilsMd5Digest(
+        data: *mut u8,
+        size: u32,
+        digest: *mut u8,
+    ) -> i32;
+    pub fn sceKernelUtilsMd5BlockInit(
+        ctx: *mut SceKernelUtilsMd5Context,
+    ) -> i32;
+    pub fn sceKernelUtilsMd5BlockUpdate(
+        ctx: *mut SceKernelUtilsMd5Context,
+        data: *mut u8,
+        size: u32,
+    ) -> i32;
+    pub fn sceKernelUtilsMd5BlockResult(
+        ctx: *mut SceKernelUtilsMd5Context,
+        digest: *mut u8,
+    ) -> i32;
+    pub fn sceKernelUtilsSha1Digest(
+        data: *mut u8,
+        size: u32,
+        digest: *mut u8,
+    ) -> i32;
+    pub fn sceKernelUtilsSha1BlockInit(
+        ctx: *mut SceKernelUtilsSha1Context,
+    ) -> i32;
+    pub fn sceKernelUtilsSha1BlockUpdate(
+        ctx: *mut SceKernelUtilsSha1Context,
+        data: *mut u8,
+        size: u32,
+    ) -> i32;
+    pub fn sceKernelUtilsSha1BlockResult(
+        ctx: *mut SceKernelUtilsSha1Context,
+        digest: *mut u8,
+    ) -> i32;
+}
+
+#[derive(Copy, Clone)]
+#[repr(packed, C)]
+pub struct IntrHandlerOptionParam {
+    size: i32,
+    entry: u32,
+    common: u32,
+    gp: u32,
+    intr_code: u16,
+    sub_count: u16,
+    intr_level: u16,
+    enabled: u16,
+    calls: u32,
+    field_1c: u32,
+    total_clock_lo: u32,
+    total_clock_hi: u32,
+    min_clock_lo: u32,
+    min_clock_hi: u32,
+    max_clock_lo: u32,
+    max_clock_hi: u32,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum Interrupt {
+    Gpio = 4,
+    Ata = 5,
+    Umd = 6,
+    Mscm0 = 7,
+    Wlan = 8,
+    Audio = 10,
+    I2c = 12,
+    Sircs = 14,
+    Systimer0 = 15,
+    Systimer1 = 16,
+    Systimer2 = 17,
+    Systimer3 = 18,
+    Thread0 = 19,
+    Nand = 20,
+    Dmacplus = 21,
+    Dma0 = 22,
+    Dma1 = 23,
+    Memlmd = 24,
+    Ge = 25,
+    Vblank = 30,
+    Mecodec = 31,
+    Hpremote = 36,
+    Mscm1 = 60,
+    Mscm2 = 61,
+    Thread1 = 65,
+    Interrupt = 66,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum SubInterrupt {
+    Gpio = Interrupt::Gpio as u32,
+    Ata = Interrupt::Ata as u32,
+    Umd = Interrupt::Umd as u32,
+    Dmacplus = Interrupt::Dmacplus as u32,
+    Ge = Interrupt::Ge as u32,
+    Display = Interrupt::Vblank as u32,
+}
+
+extern "C" {
+    pub fn sceKernelRegisterSubIntrHandler(
+        int_no: i32,
+        no: i32,
+        handler: *mut c_void,
+        arg: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelReleaseSubIntrHandler(int_no: i32, no: i32) -> i32;
+    pub fn sceKernelEnableSubIntr(int_no: i32, no: i32) -> i32;
+    pub fn sceKernelDisableSubIntr(int_no: i32, no: i32) -> i32;
+    pub fn QueryIntrHandlerInfo(
+        intr_code: SceUid,
+        sub_intr_code: SceUid,
+        data: *mut IntrHandlerOptionParam,
+    ) -> i32;
+}
+
+extern "C" {
+    pub fn sceKernelCpuSuspendIntr() -> u32;
+    pub fn sceKernelCpuResumeIntr(flags: u32);
+    pub fn sceKernelCpuResumeIntrWithSync(flags: u32);
+    pub fn sceKernelIsCpuIntrSuspended(flags: u32) -> i32;
+    pub fn sceKernelIsCpuIntrEnable() -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelLMOption {
+    pub size: usize,
+    pub m_pid_text: SceUid,
+    pub m_pid_data: SceUid,
+    pub flags: u32,
+    pub position: u8,
+    pub access: u8,
+    pub c_reserved: [u8; 2usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelSMOption {
+    pub size: usize,
+    pub m_pid_stack: SceUid,
+    pub stack_size: usize,
+    pub priority: i32,
+    pub attribute: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelModuleInfo {
+    pub size: usize,
+    pub n_segment: u8,
+    pub reserved: [u8; 3usize],
+    pub segment_addr: [i32; 4usize],
+    pub segment_size: [i32; 4usize],
+    pub entry_addr: u32,
+    pub gp_value: u32,
+    pub text_addr: u32,
+    pub text_size: u32,
+    pub data_size: u32,
+    pub bss_size: u32,
+    pub attribute: u16,
+    pub version: [u8; 2usize],
+    pub name: [u8; 28usize],
+}
+
+extern "C" {
+    pub fn sceKernelLoadModule(
+        path: *const u8,
+        flags: i32,
+        option: *mut SceKernelLMOption,
+    ) -> SceUid;
+    pub fn sceKernelLoadModuleMs(
+        path: *const u8,
+        flags: i32,
+        option: *mut SceKernelLMOption,
+    ) -> SceUid;
+    pub fn sceKernelLoadModuleByID(
+        fid: SceUid,
+        flags: i32,
+        option: *mut SceKernelLMOption,
+    ) -> SceUid;
+    pub fn sceKernelLoadModuleBufferUsbWlan(
+        buf_size: usize,
+        buf: *mut c_void,
+        flags: i32,
+        option: *mut SceKernelLMOption,
+    ) -> SceUid;
+    pub fn sceKernelStartModule(
+        mod_id: SceUid,
+        arg_size: usize,
+        argp: *mut c_void,
+        status: *mut i32,
+        option: *mut SceKernelSMOption,
+    ) -> i32;
+    pub fn sceKernelStopModule(
+        mod_id: SceUid,
+        arg_size: usize,
+        argp: *mut c_void,
+        status: *mut i32,
+        option: *mut SceKernelSMOption,
+    ) -> i32;
+    pub fn sceKernelUnloadModule(mod_id: SceUid) -> i32;
+    pub fn sceKernelSelfStopUnloadModule(
+        unknown: i32,
+        arg_size: usize,
+        argp: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelStopUnloadSelfModule(
+        arg_size: usize,
+        argp: *mut c_void,
+        status: *mut i32,
+        option: *mut SceKernelSMOption,
+    ) -> i32;
+    pub fn sceKernelQueryModuleInfo(
+        mod_id: SceUid,
+        info: *mut SceKernelModuleInfo,
+    ) -> i32;
+    pub fn sceKernelGetModuleIdList(
+        read_buf: *mut SceUid,
+        read_buf_size: i32,
+        id_count: *mut i32,
+    ) -> i32;
+}
+
+extern "C" {
+    pub fn sceKernelVolatileMemLock(
+        unk: i32,
+        ptr: *mut *mut c_void,
+        size: *mut i32,
+    ) -> i32;
+    pub fn sceKernelVolatileMemTryLock(
+        unk: i32,
+        ptr: *mut *mut c_void,
+        size: *mut i32,
+    ) -> i32;
+    pub fn sceKernelVolatileMemUnlock(unk: i32) -> i32;
+}
+
+extern "C" {
+    pub fn sceKernelStdin() -> SceUid;
+    pub fn sceKernelStdout() -> SceUid;
+    pub fn sceKernelStderr() -> SceUid;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct DebugProfilerRegs {
+    pub enable: u32,
+    pub systemck: u32,
+    pub cpuck: u32,
+    pub internal: u32,
+    pub memory: u32,
+    pub copz: u32,
+    pub vfpu: u32,
+    pub sleep: u32,
+    pub bus_access: u32,
+    pub uncached_load: u32,
+    pub uncached_store: u32,
+    pub cached_load: u32,
+    pub cached_store: u32,
+    pub i_miss: u32,
+    pub d_miss: u32,
+    pub d_writeback: u32,
+    pub cop0_inst: u32,
+    pub fpu_inst: u32,
+    pub vfpu_inst: u32,
+    pub local_bus: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelSysClock {
+    pub low: u32,
+    pub hi: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelThreadOptParam {
+    pub size: usize,
+    pub stack_mpid: SceUid,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelThreadInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub attr: u32,
+    pub status: i32,
+    pub entry: SceKernelThreadEntry,
+    pub stack: *mut c_void,
+    pub stack_size: i32,
+    pub gp_reg: *mut c_void,
+    pub init_priority: i32,
+    pub current_priority: i32,
+    pub wait_type: i32,
+    pub wait_id: SceUid,
+    pub wakeup_count: i32,
+    pub exit_status: i32,
+    pub run_clocks: SceKernelSysClock,
+    pub intr_preempt_count: u32,
+    pub thread_preempt_count: u32,
+    pub release_count: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelThreadRunStatus {
+    pub size: usize,
+    pub status: i32,
+    pub current_priority: i32,
+    pub wait_type: i32,
+    pub wait_id: i32,
+    pub wakeup_count: i32,
+    pub run_clocks: SceKernelSysClock,
+    pub intr_preempt_count: u32,
+    pub thread_preempt_count: u32,
+    pub release_count: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelSemaOptParam {
+    pub size: usize,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelSemaInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub attr: u32,
+    pub init_count: i32,
+    pub current_count: i32,
+    pub max_count: i32,
+    pub num_wait_threads: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelEventFlagInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub attr: u32,
+    pub init_pattern: u32,
+    pub current_pattern: u32,
+    pub num_wait_threads: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelEventFlagOptParam {
+    pub size: usize,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelMbxOptParam {
+    pub size: usize,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelMbxInfo {
+    pub size: usize,
+    pub name: [u8; 32usize],
+    pub attr: u32,
+    pub num_wait_threads: i32,
+    pub num_messages: i32,
+    pub first_message: *mut c_void,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelVTimerInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub active: i32,
+    pub base: SceKernelSysClock,
+    pub current: SceKernelSysClock,
+    pub schedule: SceKernelSysClock,
+    pub handler: SceKernelVTimerHandler,
+    pub common: *mut c_void,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelThreadEventHandlerInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub thread_id: SceUid,
+    pub mask: i32,
+    pub handler: SceKernelThreadEventHandler,
+    pub common: *mut c_void,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelAlarmInfo {
+    pub size: usize,
+    pub schedule: SceKernelSysClock,
+    pub handler: SceKernelAlarmHandler,
+    pub common: *mut c_void,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum SceKernelIdListType {
+    Thread = 1,
+    Semaphore = 2,
+    EventFlag = 3,
+    Mbox = 4,
+    Vpl = 5,
+    Fpl = 6,
+    Mpipe = 7,
+    Callback = 8,
+    ThreadEventHandler = 9,
+    Alarm = 10,
+    VTimer = 11,
+    SleepThread = 64,
+    DelayThread = 65,
+    SuspendThread = 66,
+    DormantThread = 67,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelSystemStatus {
+    pub size: usize,
+    pub status: u32,
+    pub idle_clocks: SceKernelSysClock,
+    pub comes_out_of_idle_count: u32,
+    pub thread_switch_count: u32,
+    pub vfpu_switch_count: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelMppInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub attr: u32,
+    pub buf_size: i32,
+    pub free_size: i32,
+    pub num_send_wait_threads: i32,
+    pub num_receive_wait_threads: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelVplOptParam {
+    pub size: usize,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelVplInfo {
+    pub size: usize,
+    pub name: [u8; 32],
+    pub attr: u32,
+    pub pool_size: i32,
+    pub free_size: i32,
+    pub num_wait_threads: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelFplOptParam {
+    pub size: usize,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelFplInfo {
+    pub size: usize,
+    pub name: [u8; 32usize],
+    pub attr: u32,
+    pub block_size: i32,
+    pub num_blocks: i32,
+    pub free_blocks: i32,
+    pub num_wait_threads: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelVTimerOptParam {
+    pub size: usize,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceKernelCallbackInfo {
+    pub size: usize,
+    pub name: [u8; 32usize],
+    pub thread_id: SceUid,
+    pub callback: SceKernelCallbackFunction,
+    pub common: *mut c_void,
+    pub notify_count: i32,
+    pub notify_arg: i32,
+}
+
+extern "C" {
+    pub fn sceKernelGetThreadmanIdType(uid: SceUid) -> SceKernelIdListType;
+    pub fn sceKernelCreateThread(
+        name: *const u8,
+        entry: SceKernelThreadEntry,
+        init_priority: i32,
+        stack_size: i32,
+        attr: i32,
+        option: *mut SceKernelThreadOptParam,
+    ) -> SceUid;
+    pub fn sceKernelDeleteThread(thid: SceUid) -> i32;
+    pub fn sceKernelStartThread(
+        id: SceUid,
+        arg_len: usize,
+        arg_p: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelExitThread(status: i32) -> i32;
+    pub fn sceKernelExitDeleteThread(status: i32) -> i32;
+    pub fn sceKernelTerminateThread(thid: SceUid) -> i32;
+    pub fn sceKernelTerminateDeleteThread(thid: SceUid) -> i32;
+    pub fn sceKernelSuspendDispatchThread() -> i32;
+    pub fn sceKernelResumeDispatchThread(state: i32) -> i32;
+    pub fn sceKernelSleepThread() -> i32;
+    pub fn sceKernelSleepThreadCB() -> i32;
+    pub fn sceKernelWakeupThread(thid: SceUid) -> i32;
+    pub fn sceKernelCancelWakeupThread(thid: SceUid) -> i32;
+    pub fn sceKernelSuspendThread(thid: SceUid) -> i32;
+    pub fn sceKernelResumeThread(thid: SceUid) -> i32;
+    pub fn sceKernelWaitThreadEnd(thid: SceUid, timeout: *mut u32) -> i32;
+    pub fn sceKernelWaitThreadEndCB(thid: SceUid, timeout: *mut u32) -> i32;
+    pub fn sceKernelDelayThread(delay: u32) -> i32;
+    pub fn sceKernelDelayThreadCB(delay: u32) -> i32;
+    pub fn sceKernelDelaySysClockThread(delay: *mut SceKernelSysClock) -> i32;
+    pub fn sceKernelDelaySysClockThreadCB(
+        delay: *mut SceKernelSysClock,
+    ) -> i32;
+    pub fn sceKernelChangeCurrentThreadAttr(unknown: i32, attr: i32) -> i32;
+    pub fn sceKernelChangeThreadPriority(thid: SceUid, priority: i32) -> i32;
+    pub fn sceKernelRotateThreadReadyQueue(priority: i32) -> i32;
+    pub fn sceKernelReleaseWaitThread(thid: SceUid) -> i32;
+    pub fn sceKernelGetThreadId() -> i32;
+    pub fn sceKernelGetThreadCurrentPriority() -> i32;
+    pub fn sceKernelGetThreadExitStatus(thid: SceUid) -> i32;
+    pub fn sceKernelCheckThreadStack() -> i32;
+    pub fn sceKernelGetThreadStackFreeSize(thid: SceUid) -> i32;
+    pub fn sceKernelReferThreadStatus(
+        thid: SceUid,
+        info: *mut SceKernelThreadInfo,
+    ) -> i32;
+    pub fn sceKernelReferThreadRunStatus(
+        thid: SceUid,
+        status: *mut SceKernelThreadRunStatus,
+    ) -> i32;
+    pub fn sceKernelCreateSema(
+        name: *const u8,
+        attr: u32,
+        init_val: i32,
+        max_val: i32,
+        option: *mut SceKernelSemaOptParam,
+    ) -> SceUid;
+    pub fn sceKernelDeleteSema(sema_id: SceUid) -> i32;
+    pub fn sceKernelSignalSema(sema_id: SceUid, signal: i32) -> i32;
+    pub fn sceKernelWaitSema(
+        sema_id: SceUid,
+        signal: i32,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelWaitSemaCB(
+        sema_id: SceUid,
+        signal: i32,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelPollSema(sema_id: SceUid, signal: i32) -> i32;
+    pub fn sceKernelReferSemaStatus(
+        sema_id: SceUid,
+        info: *mut SceKernelSemaInfo,
+    ) -> i32;
+    pub fn sceKernelCreateEventFlag(
+        name: *const u8,
+        attr: i32,
+        bits: i32,
+        opt: *mut SceKernelEventFlagOptParam,
+    ) -> SceUid;
+    pub fn sceKernelSetEventFlag(ev_id: SceUid, bits: u32) -> i32;
+    pub fn sceKernelClearEventFlag(ev_id: SceUid, bits: u32) -> i32;
+    pub fn sceKernelPollEventFlag(
+        ev_id: SceUid,
+        bits: u32,
+        wait: i32,
+        out_bits: *mut u32,
+    ) -> i32;
+    pub fn sceKernelWaitEventFlag(
+        ev_id: SceUid,
+        bits: u32,
+        wait: i32,
+        out_bits: *mut u32,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelWaitEventFlagCB(
+        ev_id: SceUid,
+        bits: u32,
+        wait: i32,
+        out_bits: *mut u32,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelDeleteEventFlag(ev_id: SceUid) -> i32;
+    pub fn sceKernelReferEventFlagStatus(
+        event: SceUid,
+        status: *mut SceKernelEventFlagInfo,
+    ) -> i32;
+    pub fn sceKernelCreateMbx(
+        name: *const u8,
+        attr: u32,
+        option: *mut SceKernelMbxOptParam,
+    ) -> SceUid;
+    pub fn sceKernelDeleteMbx(mbx_id: SceUid) -> i32;
+    pub fn sceKernelSendMbx(mbx_id: SceUid, message: *mut c_void) -> i32;
+    pub fn sceKernelReceiveMbx(
+        mbx_id: SceUid,
+        message: *mut *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelReceiveMbxCB(
+        mbx_id: SceUid,
+        message: *mut *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelPollMbx(mbx_id: SceUid, pmessage: *mut *mut c_void)
+        -> i32;
+    pub fn sceKernelCancelReceiveMbx(mbx_id: SceUid, num: *mut i32) -> i32;
+    pub fn sceKernelReferMbxStatus(
+        mbx_id: SceUid,
+        info: *mut SceKernelMbxInfo,
+    ) -> i32;
+    pub fn sceKernelSetAlarm(
+        clock: u32,
+        handler: SceKernelAlarmHandler,
+        common: *mut c_void,
+    ) -> SceUid;
+    pub fn sceKernelSetSysClockAlarm(
+        clock: *mut SceKernelSysClock,
+        handler: *mut SceKernelAlarmHandler,
+        common: *mut c_void,
+    ) -> SceUid;
+    pub fn sceKernelCancelAlarm(alarm_id: SceUid) -> i32;
+    pub fn sceKernelReferAlarmStatus(
+        alarm_id: SceUid,
+        info: *mut SceKernelAlarmInfo,
+    ) -> i32;
+    pub fn sceKernelCreateCallback(
+        name: *const u8,
+        func: SceKernelCallbackFunction,
+        arg: *mut c_void,
+    ) -> SceUid;
+    pub fn sceKernelReferCallbackStatus(
+        cb: SceUid,
+        status: *mut SceKernelCallbackInfo,
+    ) -> i32;
+    pub fn sceKernelDeleteCallback(cb: SceUid) -> i32;
+    pub fn sceKernelNotifyCallback(cb: SceUid, arg2: i32) -> i32;
+    pub fn sceKernelCancelCallback(cb: SceUid) -> i32;
+    pub fn sceKernelGetCallbackCount(cb: SceUid) -> i32;
+    pub fn sceKernelCheckCallback() -> i32;
+    pub fn sceKernelGetThreadmanIdList(
+        type_: SceKernelIdListType,
+        read_buf: *mut SceUid,
+        read_buf_size: i32,
+        id_count: *mut i32,
+    ) -> i32;
+    pub fn sceKernelReferSystemStatus(
+        status: *mut SceKernelSystemStatus,
+    ) -> i32;
+    pub fn sceKernelCreateMsgPipe(
+        name: *const u8,
+        part: i32,
+        attr: i32,
+        unk1: *mut c_void,
+        opt: *mut c_void,
+    ) -> SceUid;
+    pub fn sceKernelDeleteMsgPipe(uid: SceUid) -> i32;
+    pub fn sceKernelSendMsgPipe(
+        uid: SceUid,
+        message: *mut c_void,
+        size: u32,
+        unk1: i32,
+        unk2: *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelSendMsgPipeCB(
+        uid: SceUid,
+        message: *mut c_void,
+        size: u32,
+        unk1: i32,
+        unk2: *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelTrySendMsgPipe(
+        uid: SceUid,
+        message: *mut c_void,
+        size: u32,
+        unk1: i32,
+        unk2: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelReceiveMsgPipe(
+        uid: SceUid,
+        message: *mut c_void,
+        size: u32,
+        unk1: i32,
+        unk2: *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelReceiveMsgPipeCB(
+        uid: SceUid,
+        message: *mut c_void,
+        size: u32,
+        unk1: i32,
+        unk2: *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelTryReceiveMsgPipe(
+        uid: SceUid,
+        message: *mut c_void,
+        size: u32,
+        unk1: i32,
+        unk2: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelCancelMsgPipe(
+        uid: SceUid,
+        send: *mut i32,
+        recv: *mut i32,
+    ) -> i32;
+    pub fn sceKernelReferMsgPipeStatus(
+        uid: SceUid,
+        info: *mut SceKernelMppInfo,
+    ) -> i32;
+    pub fn sceKernelCreateVpl(
+        name: *const u8,
+        part: i32,
+        attr: i32,
+        size: u32,
+        opt: *mut SceKernelVplOptParam,
+    ) -> SceUid;
+    pub fn sceKernelDeleteVpl(uid: SceUid) -> i32;
+    pub fn sceKernelAllocateVpl(
+        uid: SceUid,
+        size: u32,
+        data: *mut *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelAllocateVplCB(
+        uid: SceUid,
+        size: u32,
+        data: *mut *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelTryAllocateVpl(
+        uid: SceUid,
+        size: u32,
+        data: *mut *mut c_void,
+    ) -> i32;
+    pub fn sceKernelFreeVpl(uid: SceUid, data: *mut c_void) -> i32;
+    pub fn sceKernelCancelVpl(uid: SceUid, num: *mut i32) -> i32;
+    pub fn sceKernelReferVplStatus(
+        uid: SceUid,
+        info: *mut SceKernelVplInfo,
+    ) -> i32;
+    pub fn sceKernelCreateFpl(
+        name: *const u8,
+        part: i32,
+        attr: i32,
+        size: u32,
+        blocks: u32,
+        opt: *mut SceKernelFplOptParam,
+    ) -> i32;
+    pub fn sceKernelDeleteFpl(uid: SceUid) -> i32;
+    pub fn sceKernelAllocateFpl(
+        uid: SceUid,
+        data: *mut *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelAllocateFplCB(
+        uid: SceUid,
+        data: *mut *mut c_void,
+        timeout: *mut u32,
+    ) -> i32;
+    pub fn sceKernelTryAllocateFpl(uid: SceUid, data: *mut *mut c_void)
+        -> i32;
+    pub fn sceKernelFreeFpl(uid: SceUid, data: *mut c_void) -> i32;
+    pub fn sceKernelCancelFpl(uid: SceUid, pnum: *mut i32) -> i32;
+    pub fn sceKernelReferFplStatus(
+        uid: SceUid,
+        info: *mut SceKernelFplInfo,
+    ) -> i32;
+    pub fn sceKernelUSec2SysClock(
+        usec: u32,
+        clock: *mut SceKernelSysClock,
+    ) -> i32;
+    pub fn sceKernelUSec2SysClockWide(usec: u32) -> i64;
+    pub fn sceKernelSysClock2USec(
+        clock: *mut SceKernelSysClock,
+        low: *mut u32,
+        high: *mut u32,
+    ) -> i32;
+    pub fn sceKernelSysClock2USecWide(
+        clock: i64,
+        low: *mut u32,
+        high: *mut u32,
+    ) -> i32;
+    pub fn sceKernelGetSystemTime(time: *mut SceKernelSysClock) -> i32;
+    pub fn sceKernelGetSystemTimeWide() -> i64;
+    pub fn sceKernelGetSystemTimeLow() -> u32;
+    pub fn sceKernelCreateVTimer(
+        name: *const u8,
+        opt: *mut SceKernelVTimerOptParam,
+    ) -> SceUid;
+    pub fn sceKernelDeleteVTimer(uid: SceUid) -> i32;
+    pub fn sceKernelGetVTimerBase(
+        uid: SceUid,
+        base: *mut SceKernelSysClock,
+    ) -> i32;
+    pub fn sceKernelGetVTimerBaseWide(uid: SceUid) -> i64;
+    pub fn sceKernelGetVTimerTime(
+        uid: SceUid,
+        time: *mut SceKernelSysClock,
+    ) -> i32;
+    pub fn sceKernelGetVTimerTimeWide(uid: SceUid) -> i64;
+    pub fn sceKernelSetVTimerTime(
+        uid: SceUid,
+        time: *mut SceKernelSysClock,
+    ) -> i32;
+    pub fn sceKernelSetVTimerTimeWide(uid: SceUid, time: i64) -> i64;
+    pub fn sceKernelStartVTimer(uid: SceUid) -> i32;
+    pub fn sceKernelStopVTimer(uid: SceUid) -> i32;
+    pub fn sceKernelSetVTimerHandler(
+        uid: SceUid,
+        time: *mut SceKernelSysClock,
+        handler: SceKernelVTimerHandler,
+        common: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelSetVTimerHandlerWide(
+        uid: SceUid,
+        time: i64,
+        handler: SceKernelVTimerHandlerWide,
+        common: *mut c_void,
+    ) -> i32;
+    pub fn sceKernelCancelVTimerHandler(uid: SceUid) -> i32;
+    pub fn sceKernelReferVTimerStatus(
+        uid: SceUid,
+        info: *mut SceKernelVTimerInfo,
+    ) -> i32;
+    pub fn sceKernelRegisterThreadEventHandler(
+        name: *const u8,
+        thread_id: SceUid,
+        mask: i32,
+        handler: SceKernelThreadEventHandler,
+        common: *mut c_void,
+    ) -> SceUid;
+    pub fn sceKernelReleaseThreadEventHandler(uid: SceUid) -> i32;
+    pub fn sceKernelReferThreadEventHandlerStatus(
+        uid: SceUid,
+        info: *mut SceKernelThreadEventHandlerInfo,
+    ) -> i32;
+    pub fn sceKernelReferThreadProfiler() -> *mut DebugProfilerRegs;
+    pub fn sceKernelReferGlobalProfiler() -> *mut DebugProfilerRegs;
+}
+
+extern "C" {
+    pub fn sceUsbStart(
+        driver_name: *const u8,
+        size: i32,
+        args: *mut c_void,
+    ) -> i32;
+    pub fn sceUsbStop(
+        driver_name: *const u8,
+        size: i32,
+        args: *mut c_void,
+    ) -> i32;
+    pub fn sceUsbActivate(pid: u32) -> i32;
+    pub fn sceUsbDeactivate(pid: u32) -> i32;
+    pub fn sceUsbGetState() -> i32;
+    pub fn sceUsbGetDrvState(driver_name: *const u8) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UsbCamSetupStillParam {
+    pub size: i32,
+    pub resolution: UsbCamResolution,
+    pub jpeg_size: i32,
+    pub reverse_flags: i32,
+    pub delay: UsbCamDelay,
+    pub comp_level: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UsbCamSetupStillExParam {
+    pub size: i32,
+    pub unk: u32,
+    pub resolution: UsbCamResolutionEx,
+    pub jpeg_size: i32,
+    pub comp_level: i32,
+    pub unk2: u32,
+    pub unk3: u32,
+    pub flip: i32,
+    pub mirror: i32,
+    pub delay: UsbCamDelay,
+    pub unk4: [u32; 5usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UsbCamSetupVideoParam {
+    pub size: i32,
+    pub resolution: UsbCamResolution,
+    pub framerate: UsbCamFrameRate,
+    pub white_balance: UsbCamWb,
+    pub saturation: i32,
+    pub brightness: i32,
+    pub contrast: i32,
+    pub sharpness: i32,
+    pub effect_mode: UsbCamEffectMode,
+    pub frame_size: i32,
+    pub unk: u32,
+    pub evl_evel: UsbCamEvLevel,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UsbCamSetupVideoExParam {
+    pub size: i32,
+    pub unk: u32,
+    pub resolution: UsbCamResolutionEx,
+    pub framerate: UsbCamFrameRate,
+    pub unk2: u32,
+    pub unk3: u32,
+    pub white_balance: UsbCamWb,
+    pub saturation: i32,
+    pub brightness: i32,
+    pub contrast: i32,
+    pub sharpness: i32,
+    pub unk4: u32,
+    pub unk5: u32,
+    pub unk6: [u32; 3usize],
+    pub effect_mode: UsbCamEffectMode,
+    pub unk7: u32,
+    pub unk8: u32,
+    pub unk9: u32,
+    pub unk10: u32,
+    pub unk11: u32,
+    pub frame_size: i32,
+    pub unk12: u32,
+    pub ev_level: UsbCamEvLevel,
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone)]
+pub enum UsbCamResolution {
+    Px160_120  = 0,
+    Px176_144  = 1,
+    Px320_240  = 2,
+    Px352_288  = 3,
+    Px640_480  = 4,
+    Px1024_768 = 5,
+    Px1280_960 = 6,
+    Px480_272  = 7,
+    Px360_272  = 8,
+}
+
+#[derive(Copy, Clone)]
+#[repr(i32)]
+pub enum UsbCamResolutionEx {
+    Px160_120  = 0,
+    Px176_144  = 1,
+    Px320_240  = 2,
+    Px352_288  = 3,
+    Px360_272  = 4,
+    Px480_272  = 5,
+    Px640_480  = 6,
+    Px1024_768 = 7,
+    Px1280_960 = 8,
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone)]
+pub enum UsbCamDelay {
+    NoDelay = 0,
+    Delay10Sec = 1,
+    Delay20Sec = 2,
+    Delay30Sec = 3,
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone)]
+pub enum UsbCamFrameRate {
+    Fps3_75 = 0,
+    Fps5 = 1,
+    Fps7_5 = 2,
+    Fps10 = 3,
+    Fps15 = 4,
+    Fps20 = 5,
+    Fps30 = 6,
+    Fps60 = 7,
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone)]
+pub enum UsbCamWb {
+    Auto = 0,
+    Daylight = 1,
+    Fluorescent = 2,
+    Incadescent = 3,
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone)]
+pub enum UsbCamEffectMode {
+    Normal = 0,
+    Negative = 1,
+    Blackwhite = 2,
+    Sepia = 3,
+    Blue = 4,
+    Red = 5,
+    Green = 6,
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone)]
+pub enum UsbCamEvLevel {
+    Pos2_0 = 0,
+    Pos1_7 = 1,
+    Pos1_5 = 2,
+    Pos1_3 = 3,
+    Pos1_0 = 4,
+    Pos0_7 = 5,
+    Pos0_5 = 6,
+    Pos0_3 = 7,
+    Zero = 8,
+    Neg0_3,
+    Neg0_5,
+    Neg0_7,
+    Neg1_0,
+    Neg1_3,
+    Neg1_5,
+    Neg1_7,
+    Neg2_0,
+}
+
+extern "C" {
+    pub fn sceUsbCamSetupStill(param: *mut UsbCamSetupStillParam) -> i32;
+    pub fn sceUsbCamSetupStillEx(param: *mut UsbCamSetupStillExParam) -> i32;
+    pub fn sceUsbCamStillInputBlocking(buf: *mut u8, size: usize) -> i32;
+    pub fn sceUsbCamStillInput(buf: *mut u8, size: usize) -> i32;
+    pub fn sceUsbCamStillWaitInputEnd() -> i32;
+    pub fn sceUsbCamStillPollInputEnd() -> i32;
+    pub fn sceUsbCamStillCancelInput() -> i32;
+    pub fn sceUsbCamStillGetInputLength() -> i32;
+    pub fn sceUsbCamSetupVideo(
+        param: *mut UsbCamSetupVideoParam,
+        work_area: *mut c_void,
+        work_area_size: i32,
+    ) -> i32;
+    pub fn sceUsbCamSetupVideoEx(
+        param: *mut UsbCamSetupVideoExParam,
+        work_area: *mut c_void,
+        work_area_size: i32,
+    ) -> i32;
+    pub fn sceUsbCamStartVideo() -> i32;
+    pub fn sceUsbCamStopVideo() -> i32;
+    pub fn sceUsbCamReadVideoFrameBlocking(buf: *mut u8, size: usize) -> i32;
+    pub fn sceUsbCamReadVideoFrame(buf: *mut u8, size: usize) -> i32;
+    pub fn sceUsbCamWaitReadVideoFrameEnd() -> i32;
+    pub fn sceUsbCamPollReadVideoFrameEnd() -> i32;
+    pub fn sceUsbCamGetReadVideoFrameSize() -> i32;
+    pub fn sceUsbCamSetSaturation(saturation: i32) -> i32;
+    pub fn sceUsbCamSetBrightness(brightness: i32) -> i32;
+    pub fn sceUsbCamSetContrast(contrast: i32) -> i32;
+    pub fn sceUsbCamSetSharpness(sharpness: i32) -> i32;
+    pub fn sceUsbCamSetImageEffectMode(effect_mode: UsbCamEffectMode) -> i32;
+    pub fn sceUsbCamSetEvLevel(exposure_level: UsbCamEvLevel) -> i32;
+    pub fn sceUsbCamSetReverseMode(reverse_flags: i32) -> i32;
+    pub fn sceUsbCamSetZoom(zoom: i32) -> i32;
+    pub fn sceUsbCamGetSaturation(saturation: *mut i32) -> i32;
+    pub fn sceUsbCamGetBrightness(brightness: *mut i32) -> i32;
+    pub fn sceUsbCamGetContrast(contrast: *mut i32) -> i32;
+    pub fn sceUsbCamGetSharpness(sharpness: *mut i32) -> i32;
+    pub fn sceUsbCamGetImageEffectMode(
+        effect_mode: *mut UsbCamEffectMode,
+    ) -> i32;
+    pub fn sceUsbCamGetEvLevel(exposure_level: *mut UsbCamEvLevel) -> i32;
+    pub fn sceUsbCamGetReverseMode(
+        reverse_flags: *mut i32,
+    ) -> i32;
+    pub fn sceUsbCamGetZoom(zoom: *mut i32) -> i32;
+    pub fn sceUsbCamAutoImageReverseSW(on: i32) -> i32;
+    pub fn sceUsbCamGetAutoImageReverseState() -> i32;
+    pub fn sceUsbCamGetLensDirection() -> i32;
+}
+
+extern "C" {
+    pub fn sceUsbstorBootRegisterNotify(event_flag: SceUid) -> i32;
+    pub fn sceUsbstorBootUnregisterNotify(event_flag: u32) -> i32;
+    pub fn sceUsbstorBootSetCapacity(size: u32) -> i32;
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum PowerTick {
+    All = 0,
+    Suspend = 1,
+    Display = 6,
+}
+
+extern "C" {
+    pub fn scePowerRegisterCallback(slot: i32, cbid: SceUid) -> i32;
+    pub fn scePowerUnregisterCallback(slot: i32) -> i32;
+    pub fn scePowerIsPowerOnline() -> i32;
+    pub fn scePowerIsBatteryExist() -> i32;
+    pub fn scePowerIsBatteryCharging() -> i32;
+    pub fn scePowerGetBatteryChargingStatus() -> i32;
+    pub fn scePowerIsLowBattery() -> i32;
+    pub fn scePowerGetBatteryLifePercent() -> i32;
+    pub fn scePowerGetBatteryLifeTime() -> i32;
+    pub fn scePowerGetBatteryTemp() -> i32;
+    pub fn scePowerGetBatteryElec() -> i32;
+    pub fn scePowerGetBatteryVolt() -> i32;
+    pub fn scePowerSetCpuClockFrequency(cpufreq: i32) -> i32;
+    pub fn scePowerSetBusClockFrequency(busfreq: i32) -> i32;
+    pub fn scePowerGetCpuClockFrequency() -> i32;
+    pub fn scePowerGetCpuClockFrequencyInt() -> i32;
+    pub fn scePowerGetCpuClockFrequencyFloat() -> f32;
+    pub fn scePowerGetBusClockFrequency() -> i32;
+    pub fn scePowerGetBusClockFrequencyInt() -> i32;
+    pub fn scePowerGetBusClockFrequencyFloat() -> f32;
+    pub fn scePowerSetClockFrequency(
+        pllfreq: i32,
+        cpufreq: i32,
+        busfreq: i32,
+    ) -> i32;
+    pub fn scePowerLock(unknown: i32) -> i32;
+    pub fn scePowerUnlock(unknown: i32) -> i32;
+    pub fn scePowerTick(t: PowerTick) -> i32;
+    pub fn scePowerGetIdleTimer() -> i32;
+    pub fn scePowerIdleTimerEnable(unknown: i32) -> i32;
+    pub fn scePowerIdleTimerDisable(unknown: i32) -> i32;
+    pub fn scePowerRequestStandby() -> i32;
+    pub fn scePowerRequestSuspend() -> i32;
+}
+
+extern "C" {
+    pub fn sceWlanDevIsPowerOn() -> i32;
+    pub fn sceWlanGetSwitchState() -> i32;
+    pub fn sceWlanGetEtherAddr(ether_addr: *mut u8) -> i32;
+}
+
+extern "C" {
+    pub fn sceWlanDevAttach() -> i32;
+    pub fn sceWlanDevDetach() -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspDateTime {
+    pub year: u16,
+    pub month: u16,
+    pub day: u16,
+    pub hour: u16,
+    pub minutes: u16,
+    pub seconds: u16,
+    pub microseconds: u32,
+}
+
+#[repr(i32)]
+#[derive(Eq, PartialEq, Copy, Clone)]
+pub enum RtcCheckValidError {
+    InvalidYear = -1,
+    InvalidMonth = -2,
+    InvalidDay = -3,
+    InvalidHour = -4,
+    InvalidMinutes = -5,
+    InvalidSeconds = -6,
+    InvalidMicroseconds = -7,
+}
+
+extern "C" {
+    pub fn sceRtcGetTickResolution() -> u32;
+    pub fn sceRtcGetCurrentTick(tick: *mut u64) -> i32;
+    pub fn sceRtcGetCurrentClock(tm: *mut ScePspDateTime, tz: i32) -> i32;
+    pub fn sceRtcGetCurrentClockLocalTime(tm: *mut ScePspDateTime) -> i32;
+    pub fn sceRtcConvertUtcToLocalTime(
+        tick_utc: *const u64,
+        tick_local: *mut u64,
+    ) -> i32;
+    pub fn sceRtcConvertLocalTimeToUTC(
+        tick_local: *const u64,
+        tick_utc: *mut u64,
+    ) -> i32;
+    pub fn sceRtcIsLeapYear(year: i32) -> i32;
+    pub fn sceRtcGetDaysInMonth(year: i32, month: i32) -> i32;
+    pub fn sceRtcGetDayOfWeek(year: i32, month: i32, day: i32) -> i32;
+    pub fn sceRtcCheckValid(date: *const ScePspDateTime) -> i32;
+    pub fn sceRtcSetTick(date: *mut ScePspDateTime, tick: *const u64) -> i32;
+    pub fn sceRtcGetTick(date: *const ScePspDateTime, tick: *mut u64) -> i32;
+    pub fn sceRtcCompareTick(tick1: *const u64, tick2: *const u64) -> i32;
+    pub fn sceRtcTickAddTicks(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_ticks: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddMicroseconds(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_ms: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddSeconds(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_seconds: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddMinutes(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_minutes: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddHours(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_hours: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddDays(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_days: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddWeeks(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_weeks: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddMonths(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_months: u64,
+    ) -> i32;
+    pub fn sceRtcTickAddYears(
+        dest_tick: *mut u64,
+        src_tick: *const u64,
+        num_years: u64,
+    ) -> i32;
+    pub fn sceRtcSetTime_t(date: *mut ScePspDateTime, time: i64) -> i32;
+    pub fn sceRtcGetTime_t(date: *const ScePspDateTime, time: *mut i64)
+        -> i32;
+    pub fn sceRtcSetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
+    pub fn sceRtcGetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
+    pub fn sceRtcSetWin32FileTime(
+        date: *mut ScePspDateTime,
+        time: *mut u64,
+    ) -> i32;
+    pub fn sceRtcGetWin32FileTime(
+        date: *mut ScePspDateTime,
+        time: *mut u64,
+    ) -> i32;
+    pub fn sceRtcParseDateTime(
+        dest_tick: *mut u64,
+        date_string: *const u8,
+    ) -> i32;
+    pub fn sceRtcFormatRFC3339(
+        psz_date_time: *mut char,
+        p_utc: *const u64,
+        time_zone_minutes: i32,
+    ) -> i32;
+    pub fn sceRtcFormatRFC3339LocalTime(
+        psz_date_time: *mut char,
+        p_utc: *const u64,
+    ) -> i32;
+    pub fn sceRtcParseRFC3339(
+        p_utc: *mut u64,
+        psz_date_time: *const u8,
+    ) -> i32;
+    pub fn sceRtcFormatRFC2822(
+        psz_date_time: *mut char,
+        p_utc: *const u64,
+        time_zone_minutes: i32,
+    ) -> i32;
+    pub fn sceRtcFormatRFC2822LocalTime(
+        psz_date_time: *mut char,
+        p_utc: *const u64,
+    ) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceIoDirent {
+    pub d_stat: SceIoStat,
+    pub d_name: [u8; 256usize],
+    pub d_private: *mut c_void,
+    pub dummy: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceIoStat {
+    pub st_mode: i32,
+    pub st_attr: i32,
+    pub st_size: i64,
+    pub st_ctime: ScePspDateTime,
+    pub st_atime: ScePspDateTime,
+    pub st_mtime: ScePspDateTime,
+    pub st_private: [u32; 6usize],
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum IoAssignPerms {
+    RdWr = 0,
+    RdOnly = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum IoWhence {
+    Set = 0,
+    Cur = 1,
+    End = 2,
+}
+
+extern "C" {
+    pub fn sceIoOpen(
+        file: *const u8,
+        flags: i32,
+        permissions: IoPermissions,
+    ) -> SceUid;
+    pub fn sceIoOpenAsync(
+        file: *const u8,
+        flags: i32,
+        permissions: IoPermissions,
+    ) -> SceUid;
+    pub fn sceIoClose(fd: SceUid) -> i32;
+    pub fn sceIoCloseAsync(fd: SceUid) -> i32;
+    pub fn sceIoRead(fd: SceUid, data: *mut c_void, size: u32) -> i32;
+    pub fn sceIoReadAsync(fd: SceUid, data: *mut c_void, size: u32) -> i32;
+    pub fn sceIoWrite(fd: SceUid, data: *const c_void, size: usize) -> i32;
+    pub fn sceIoWriteAsync(fd: SceUid, data: *const c_void, size: u32) -> i32;
+    pub fn sceIoLseek(fd: SceUid, offset: i64, whence: IoWhence) -> i64;
+    pub fn sceIoLseekAsync(fd: SceUid, offset: i64, whence: IoWhence) -> i32;
+    pub fn sceIoLseek32(fd: SceUid, offset: i32, whence: IoWhence) -> i32;
+    pub fn sceIoLseek32Async(fd: SceUid, offset: i32, whence: IoWhence)
+        -> i32;
+    pub fn sceIoRemove(file: *const u8) -> i32;
+    pub fn sceIoMkdir(dir: *const u8, mode: IoPermissions) -> i32;
+    pub fn sceIoRmdir(path: *const u8) -> i32;
+    pub fn sceIoChdir(path: *const u8) -> i32;
+    pub fn sceIoRename(oldname: *const u8, newname: *const u8) -> i32;
+    pub fn sceIoDopen(dirname: *const u8) -> SceUid;
+    pub fn sceIoDread(fd: SceUid, dir: *mut SceIoDirent) -> i32;
+    pub fn sceIoDclose(fd: SceUid) -> i32;
+    pub fn sceIoDevctl(
+        dev: *const u8,
+        cmd: u32,
+        indata: *mut c_void,
+        inlen: i32,
+        outdata: *mut c_void,
+        outlen: i32,
+    ) -> i32;
+    pub fn sceIoAssign(
+        dev1: *const u8,
+        dev2: *const u8,
+        dev3: *const u8,
+        mode: IoAssignPerms,
+        unk1: *mut c_void,
+        unk2: i32,
+    ) -> i32;
+    pub fn sceIoUnassign(dev: *const u8) -> i32;
+    pub fn sceIoGetstat(file: *const u8, stat: *mut SceIoStat) -> i32;
+    pub fn sceIoChstat(
+        file: *const u8,
+        stat: *mut SceIoStat,
+        bits: i32,
+    ) -> i32;
+    pub fn sceIoIoctl(
+        fd: SceUid,
+        cmd: u32,
+        indata: *mut c_void,
+        inlen: i32,
+        outdata: *mut c_void,
+        outlen: i32,
+    ) -> i32;
+    pub fn sceIoIoctlAsync(
+        fd: SceUid,
+        cmd: u32,
+        indata: *mut c_void,
+        inlen: i32,
+        outdata: *mut c_void,
+        outlen: i32,
+    ) -> i32;
+    pub fn sceIoSync(device: *const u8, unk: u32) -> i32;
+    pub fn sceIoWaitAsync(fd: SceUid, res: *mut i64) -> i32;
+    pub fn sceIoWaitAsyncCB(fd: SceUid, res: *mut i64) -> i32;
+    pub fn sceIoPollAsync(fd: SceUid, res: *mut i64) -> i32;
+    pub fn sceIoGetAsyncStat(fd: SceUid, poll: i32, res: *mut i64) -> i32;
+    pub fn sceIoCancel(fd: SceUid) -> i32;
+    pub fn sceIoGetDevType(fd: SceUid) -> i32;
+    pub fn sceIoChangeAsyncPriority(fd: SceUid, pri: i32) -> i32;
+    pub fn sceIoSetAsyncCallback(
+        fd: SceUid,
+        cb: SceUid,
+        argp: *mut c_void,
+    ) -> i32;
+}
+
+extern "C" {
+    pub fn sceJpegInitMJpeg() -> i32;
+    pub fn sceJpegFinishMJpeg() -> i32;
+    pub fn sceJpegCreateMJpeg(width: i32, height: i32) -> i32;
+    pub fn sceJpegDeleteMJpeg() -> i32;
+    pub fn sceJpegDecodeMJpeg(
+        jpeg_buf: *mut u8,
+        size: usize,
+        rgba: *mut c_void,
+        unk: u32,
+    ) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UmdInfo {
+    pub size: u32,
+    pub type_: UmdType,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum UmdType {
+    Game = 0x10,
+    Video = 0x20,
+    Audio = 0x40,
+}
+
+extern "C" {
+    pub fn sceUmdCheckMedium() -> i32;
+    pub fn sceUmdGetDiscInfo(info: *mut UmdInfo) -> i32;
+    pub fn sceUmdActivate(unit: i32, drive: *const u8) -> i32;
+    pub fn sceUmdDeactivate(unit: i32, drive: *const u8) -> i32;
+    pub fn sceUmdWaitDriveStat(state: i32) -> i32;
+    pub fn sceUmdWaitDriveStatWithTimer(
+        state: i32,
+        timeout: u32,
+    ) -> i32;
+    pub fn sceUmdWaitDriveStatCB(
+        state: i32,
+        timeout: u32,
+    ) -> i32;
+    pub fn sceUmdCancelWaitDriveStat() -> i32;
+    pub fn sceUmdGetDriveStat() -> i32;
+    pub fn sceUmdGetErrorStat() -> i32;
+    pub fn sceUmdRegisterUMDCallBack(cbid: i32) -> i32;
+    pub fn sceUmdUnRegisterUMDCallBack(cbid: i32) -> i32;
+    pub fn sceUmdReplacePermit() -> i32;
+    pub fn sceUmdReplaceProhibit() -> i32;
+}
+
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct SceMpeg(*mut *mut c_void);
+
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct SceMpegStream(*mut c_void);
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceMpegRingbuffer {
+    pub packets: i32,
+    pub unk0: u32,
+    pub unk1: u32,
+    pub unk2: u32,
+    pub unk3: u32,
+    pub data: *mut c_void,
+    pub callback: SceMpegRingbufferCb,
+    pub cb_param: *mut c_void,
+    pub unk4: u32,
+    pub unk5: u32,
+    pub sce_mpeg: *mut c_void,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceMpegAu {
+    pub pts_msb: u32,
+    pub pts: u32,
+    pub dts_msb: u32,
+    pub dts: u32,
+    pub es_buffer: u32,
+    pub au_size: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceMpegAvcMode {
+    pub unk0: i32,
+    pub pixel_format: super::DisplayPixelFormat,
+}
+
+extern "C" {
+    pub fn sceMpegInit() -> i32;
+    pub fn sceMpegFinish();
+    pub fn sceMpegRingbufferQueryMemSize(packets: i32) -> i32;
+    pub fn sceMpegRingbufferConstruct(
+        ringbuffer: *mut SceMpegRingbuffer,
+        packets: i32,
+        data: *mut c_void,
+        size: i32,
+        callback: SceMpegRingbufferCb,
+        cb_param: *mut c_void,
+    ) -> i32;
+    pub fn sceMpegRingbufferDestruct(ringbuffer: *mut SceMpegRingbuffer);
+    pub fn sceMpegRingbufferAvailableSize(
+        ringbuffer: *mut SceMpegRingbuffer,
+    ) -> i32;
+    pub fn sceMpegRingbufferPut(
+        ringbuffer: *mut SceMpegRingbuffer,
+        num_packets: i32,
+        available: i32,
+    ) -> i32;
+    pub fn sceMpegQueryMemSize(unk: i32) -> i32;
+    pub fn sceMpegCreate(
+        handle: SceMpeg,
+        data: *mut c_void,
+        size: i32,
+        ringbuffer: *mut SceMpegRingbuffer,
+        frame_width: i32,
+        unk1: i32,
+        unk2: i32,
+    ) -> i32;
+    pub fn sceMpegDelete(handle: SceMpeg);
+    pub fn sceMpegQueryStreamOffset(
+        handle: SceMpeg,
+        buffer: *mut c_void,
+        offset: *mut i32,
+    ) -> i32;
+    pub fn sceMpegQueryStreamSize(buffer: *mut c_void, size: *mut i32) -> i32;
+    pub fn sceMpegRegistStream(
+        handle: SceMpeg,
+        stream_id: i32,
+        unk: i32,
+    ) -> SceMpegStream;
+    pub fn sceMpegUnRegistStream(handle: SceMpeg, stream: SceMpegStream);
+    pub fn sceMpegFlushAllStream(handle: SceMpeg) -> i32;
+    pub fn sceMpegMallocAvcEsBuf(handle: SceMpeg) -> *mut c_void;
+    pub fn sceMpegFreeAvcEsBuf(handle: SceMpeg, buf: *mut c_void);
+    pub fn sceMpegQueryAtracEsSize(
+        handle: SceMpeg,
+        es_size: *mut i32,
+        out_size: *mut i32,
+    ) -> i32;
+    pub fn sceMpegInitAu(
+        handle: SceMpeg,
+        es_buffer: *mut c_void,
+        au: *mut SceMpegAu,
+    ) -> i32;
+    pub fn sceMpegGetAvcAu(
+        handle: SceMpeg,
+        stream: SceMpegStream,
+        au: *mut SceMpegAu,
+        unk: *mut i32,
+    ) -> i32;
+    pub fn sceMpegAvcDecodeMode(
+        handle: SceMpeg,
+        mode: *mut SceMpegAvcMode,
+    ) -> i32;
+    pub fn sceMpegAvcDecode(
+        handle: SceMpeg,
+        au: *mut SceMpegAu,
+        iframe_width: i32,
+        buffer: *mut c_void,
+        init: *mut i32,
+    ) -> i32;
+    pub fn sceMpegAvcDecodeStop(
+        handle: SceMpeg,
+        frame_width: i32,
+        buffer: *mut c_void,
+        status: *mut i32,
+    ) -> i32;
+    pub fn sceMpegGetAtracAu(
+        handle: SceMpeg,
+        stream: SceMpegStream,
+        au: *mut SceMpegAu,
+        unk: *mut c_void,
+    ) -> i32;
+    pub fn sceMpegAtracDecode(
+        handle: SceMpeg,
+        au: *mut SceMpegAu,
+        buffer: *mut c_void,
+        init: i32,
+    ) -> i32;
+}
+
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct SceMpegLLI {
+    pub src: *mut c_void,
+    pub dst: *mut c_void,
+    pub next: *mut c_void,
+    pub size: i32,
+}
+
+#[repr(C)]
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+pub struct SceMpegYCrCbBuffer {
+    pub frame_buffer_height16: i32,
+    pub frame_buffer_width16: i32,
+    pub unknown: i32,
+    pub unknown2: i32,
+    pub y_buffer: *mut c_void,
+    pub y_buffer2: *mut c_void,
+    pub cr_buffer: *mut c_void,
+    pub cb_buffer: *mut c_void,
+    pub cr_buffer2: *mut c_void,
+    pub cb_buffer2: *mut c_void,
+
+    pub frame_height: i32,
+    pub frame_width: i32,
+    pub frame_buffer_width: i32,
+    pub unknown3: [i32; 11usize],
+}
+
+extern "C" {
+    pub fn sceMpegBaseYCrCbCopyVme(
+        yuv_buffer: *mut c_void,
+        buffer: *mut i32,
+        type_: i32,
+    ) -> i32;
+    pub fn sceMpegBaseCscInit(width: i32) -> i32;
+    pub fn sceMpegBaseCscVme(
+        rgb_buffer: *mut c_void,
+        rgb_buffer2: *mut c_void,
+        width: i32,
+        y_cr_cb_buffer: *mut SceMpegYCrCbBuffer,
+    ) -> i32;
+    pub fn sceMpegbase_BEA18F91(lli: *mut SceMpegLLI) -> i32;
+}
+
+extern "C" {
+    pub fn sceHprmPeekCurrentKey(key: *mut i32) -> i32;
+    pub fn sceHprmPeekLatch(latch: *mut [u32;4]) -> i32;
+    pub fn sceHprmReadLatch(latch: *mut [u32;4]) -> i32;
+    pub fn sceHprmIsHeadphoneExist() -> i32;
+    pub fn sceHprmIsRemoteExist() -> i32;
+    pub fn sceHprmIsMicrophoneExist() -> i32;
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum GuPrimitive {
+    Points = 0,
+    Lines = 1,
+    LineStrip = 2,
+    Triangles = 3,
+    TriangleStrip = 4,
+    TriangleFan = 5,
+    Sprites = 6,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum PatchPrimitive {
+    Points = 0,
+    LineStrip = 2,
+    TriangleStrip = 4,
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+#[repr(u32)]
+pub enum GuState {
+    AlphaTest = 0,
+    DepthTest = 1,
+    ScissorTest = 2,
+    StencilTest = 3,
+    Blend = 4,
+    CullFace = 5,
+    Dither = 6,
+    Fog = 7,
+    ClipPlanes = 8,
+    Texture2D = 9,
+    Lighting = 10,
+    Light0 = 11,
+    Light1 = 12,
+    Light2 = 13,
+    Light3 = 14,
+    LineSmooth = 15,
+    PatchCullFace = 16,
+    ColorTest = 17,
+    ColorLogicOp = 18,
+    FaceNormalReverse = 19,
+    PatchFace = 20,
+    Fragment2X = 21,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum MatrixMode {
+    Projection = 0,
+    View = 1,
+    Model = 2,
+    Texture = 3,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum TexturePixelFormat {
+    Psm5650 = 0,
+    Psm5551 = 1,
+    Psm4444 = 2,
+    Psm8888 = 3,
+    PsmT4 = 4,
+    PsmT8 = 5,
+    PsmT16 = 6,
+    PsmT32 = 7,
+    PsmDxt1 = 8,
+    PsmDxt3 = 9,
+    PsmDxt5 = 10,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum SplineMode {
+    FillFill = 0,
+    OpenFill = 1,
+    FillOpen = 2,
+    OpenOpen = 3,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum ShadingModel {
+    Flat = 0,
+    Smooth = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum LogicalOperation {
+    Clear = 0,
+    And = 1,
+    AndReverse = 2,
+    Copy = 3,
+    AndInverted = 4,
+    Noop = 5,
+    Xor = 6,
+    Or = 7,
+    Nor = 8,
+    Equiv = 9,
+    Inverted = 10,
+    OrReverse = 11,
+    CopyInverted = 12,
+    OrInverted = 13,
+    Nand = 14,
+    Set = 15,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum TextureFilter {
+    Nearest = 0,
+    Linear = 1,
+    NearestMipmapNearest = 4,
+    LinearMipmapNearest = 5,
+    NearestMipmapLinear = 6,
+    LinearMipmapLinear = 7,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum TextureMapMode {
+    TextureCoords = 0,
+    TextureMatrix = 1,
+    EnvironmentMap = 2,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum TextureLevelMode {
+    Auto = 0,
+    Const = 1,
+    Slope = 2,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum TextureProjectionMapMode {
+    Position = 0,
+    Uv = 1,
+    NormalizedNormal = 2,
+    Normal = 3,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum GuTexWrapMode {
+    Repeat = 0,
+    Clamp = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum FrontFaceDirection {
+    Clockwise = 0,
+    CounterClockwise = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum AlphaFunc {
+    Never = 0,
+    Always,
+    Equal,
+    NotEqual,
+    Less,
+    LessOrEqual,
+    Greater,
+    GreaterOrEqual,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum StencilFunc {
+    Never = 0,
+    Always,
+    Equal,
+    NotEqual,
+    Less,
+    LessOrEqual,
+    Greater,
+    GreaterOrEqual,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum ColorFunc {
+    Never = 0,
+    Always,
+    Equal,
+    NotEqual,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum DepthFunc {
+    Never = 0,
+    Always,
+    Equal,
+    NotEqual,
+    Less,
+    LessOrEqual,
+    Greater,
+    GreaterOrEqual,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum TextureEffect {
+    Modulate = 0,
+    Decal = 1,
+    Blend = 2,
+    Replace = 3,
+    Add = 4,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum TextureColorComponent {
+    Rgb = 0,
+    Rgba = 1,
+}
+
+#[derive(Clone, Copy)]
+#[repr(u32)]
+pub enum MipmapLevel {
+    None = 0,
+    Level1,
+    Level2,
+    Level3,
+    Level4,
+    Level5,
+    Level6,
+    Level7,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum BlendOp {
+    Add = 0,
+    Subtract = 1,
+    ReverseSubtract = 2,
+    Min = 3,
+    Max = 4,
+    Abs = 5,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum BlendSrc {
+    SrcColor = 0,
+    OneMinusSrcColor = 1,
+    SrcAlpha = 2,
+    OneMinusSrcAlpha = 3,
+    Fix = 10,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum BlendDst {
+    DstColor = 0,
+    OneMinusDstColor = 1,
+    DstAlpha = 4,
+    OneMinusDstAlpha = 5,
+    Fix = 10,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum StencilOperation {
+    Keep = 0,
+    Zero = 1,
+    Replace = 2,
+    Invert = 3,
+    Incr = 4,
+    Decr = 5,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum LightMode {
+    SingleColor = 0,
+    SeparateSpecularColor = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum LightType {
+    Directional = 0,
+    Pointlight = 1,
+    Spotlight = 2,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum GuContextType {
+    Direct = 0,
+    Call = 1,
+    Send = 2,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum GuQueueMode {
+    Tail = 0,
+    Head = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum GuSyncMode {
+    Finish = 0,
+    Signal = 1,
+    Done = 2,
+    List = 3,
+    Send = 4,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum GuSyncBehavior {
+    Wait = 0,
+    NoWait = 1,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum GuCallbackId {
+    Signal = 1,
+    Finish = 4,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum SignalBehavior {
+    Suspend = 1,
+    Continue = 2,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum ClutPixelFormat {
+    Psm5650 = 0,
+    Psm5551 = 1,
+    Psm4444 = 2,
+    Psm8888 = 3,
+}
+
+extern "C" {
+    pub fn sceGuDepthBuffer(zbp: *mut c_void, zbw: i32);
+    pub fn sceGuDispBuffer(
+        width: i32,
+        height: i32,
+        dispbp: *mut c_void,
+        dispbw: i32,
+    );
+    pub fn sceGuDrawBuffer(
+        psm: DisplayPixelFormat,
+        fbp: *mut c_void,
+        fbw: i32,
+    );
+    pub fn sceGuDrawBufferList(
+        psm: DisplayPixelFormat,
+        fbp: *mut c_void,
+        fbw: i32,
+    );
+    pub fn sceGuDisplay(state: bool) -> bool;
+    pub fn sceGuDepthFunc(function: DepthFunc);
+    pub fn sceGuDepthMask(mask: i32);
+
+    pub fn sceGuDepthOffset(offset: i32);
+    pub fn sceGuDepthRange(near: i32, far: i32);
+
+    pub fn sceGuFog(near: f32, far: f32, color: u32);
+    pub fn sceGuInit();
+    pub fn sceGuTerm();
+    pub fn sceGuBreak(mode: i32);
+
+    pub fn sceGuContinue();
+    pub fn sceGuSetCallback(
+        signal: GuCallbackId,
+        callback: GuCallback,
+    ) -> GuCallback;
+    pub fn sceGuSignal(behavior: SignalBehavior, signal: i32);
+    pub fn sceGuSendCommandf(cmd: GeCommand, argument: f32);
+    pub fn sceGuSendCommandi(cmd: GeCommand, argument: i32);
+    pub fn sceGuGetMemory(size: i32) -> *mut c_void;
+    pub fn sceGuStart(context_type: GuContextType, list: *mut c_void);
+    pub fn sceGuFinish() -> i32;
+    pub fn sceGuFinishId(id: u32) -> i32;
+    pub fn sceGuCallList(list: *const c_void);
+    pub fn sceGuCallMode(mode: i32);
+    pub fn sceGuCheckList() -> i32;
+    pub fn sceGuSendList(
+        mode: GuQueueMode,
+        list: *const c_void,
+        context: *mut GeContext,
+    );
+    pub fn sceGuSwapBuffers() -> *mut c_void;
+    pub fn sceGuSync(
+        mode: GuSyncMode,
+        behavior: GuSyncBehavior,
+    ) -> GeListState;
+    pub fn sceGuDrawArray(
+        prim: GuPrimitive,
+        vtype: i32,
+        count: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+    pub fn sceGuBeginObject(
+        vtype: i32,
+        count: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+    pub fn sceGuEndObject();
+    pub fn sceGuSetStatus(state: GuState, status: i32);
+    pub fn sceGuGetStatus(state: GuState) -> bool;
+    pub fn sceGuSetAllStatus(status: i32);
+    pub fn sceGuGetAllStatus() -> i32;
+    pub fn sceGuEnable(state: GuState);
+    pub fn sceGuDisable(state: GuState);
+    pub fn sceGuLight(
+        light: i32,
+        type_: LightType,
+        components: i32,
+        position: &ScePspFVector3,
+    );
+    pub fn sceGuLightAtt(light: i32, atten0: f32, atten1: f32, atten2: f32);
+    pub fn sceGuLightColor(light: i32, component: i32, color: u32);
+    pub fn sceGuLightMode(mode: LightMode);
+    pub fn sceGuLightSpot(
+        light: i32,
+        direction: &ScePspFVector3,
+        exponent: f32,
+        cutoff: f32,
+    );
+    pub fn sceGuClear(flags: i32);
+    pub fn sceGuClearColor(color: u32);
+    pub fn sceGuClearDepth(depth: u32);
+    pub fn sceGuClearStencil(stencil: u32);
+    pub fn sceGuPixelMask(mask: u32);
+    pub fn sceGuColor(color: u32);
+    pub fn sceGuColorFunc(func: ColorFunc, color: u32, mask: u32);
+    pub fn sceGuColorMaterial(components: i32);
+    pub fn sceGuAlphaFunc(func: AlphaFunc, value: i32, mask: i32);
+
+    pub fn sceGuAmbient(color: u32);
+
+    pub fn sceGuAmbientColor(color: u32);
+    pub fn sceGuBlendFunc(
+        op: BlendOp,
+        src: BlendSrc,
+        dest: BlendDst,
+        src_fix: u32,
+        dest_fix: u32,
+    );
+    pub fn sceGuMaterial(components: i32, color: u32);
+    pub fn sceGuModelColor(
+        emissive: u32,
+        ambient: u32,
+        diffuse: u32,
+        specular: u32,
+    );
+    pub fn sceGuStencilFunc(func: StencilFunc, ref_: i32, mask: i32);
+    pub fn sceGuStencilOp(
+        fail: StencilOperation,
+        zfail: StencilOperation,
+        zpass: StencilOperation,
+    );
+    pub fn sceGuSpecular(power: f32);
+    pub fn sceGuFrontFace(order: FrontFaceDirection);
+    pub fn sceGuLogicalOp(op: LogicalOperation);
+    pub fn sceGuSetDither(matrix: &ScePspIMatrix4);
+    pub fn sceGuShadeModel(mode: ShadingModel);
+    pub fn sceGuCopyImage(
+        psm: DisplayPixelFormat,
+        sx: i32,
+        sy: i32,
+        width: i32,
+        height: i32,
+        srcw: i32,
+        src: *mut c_void,
+        dx: i32,
+        dy: i32,
+        destw: i32,
+        dest: *mut c_void,
+    );
+    pub fn sceGuTexEnvColor(color: u32);
+    pub fn sceGuTexFilter(min: TextureFilter, mag: TextureFilter);
+    pub fn sceGuTexFlush();
+    pub fn sceGuTexFunc(tfx: TextureEffect, tcc: TextureColorComponent);
+    pub fn sceGuTexImage(
+        mipmap: MipmapLevel,
+        width: i32,
+        height: i32,
+        tbw: i32,
+        tbp: *const c_void,
+    );
+    pub fn sceGuTexLevelMode(mode: TextureLevelMode, bias: f32);
+    pub fn sceGuTexMapMode(mode: TextureMapMode, a1: u32, a2: u32);
+    pub fn sceGuTexMode(
+        tpsm: TexturePixelFormat,
+        maxmips: i32,
+        a2: i32,
+        swizzle: i32,
+    );
+    pub fn sceGuTexOffset(u: f32, v: f32);
+    pub fn sceGuTexProjMapMode(mode: TextureProjectionMapMode);
+    pub fn sceGuTexScale(u: f32, v: f32);
+
+    pub fn sceGuTexSlope(slope: f32);
+    pub fn sceGuTexSync();
+    pub fn sceGuTexWrap(u: GuTexWrapMode, v: GuTexWrapMode);
+    pub fn sceGuClutLoad(num_blocks: i32, cbp: *const c_void);
+    pub fn sceGuClutMode(
+        cpsm: ClutPixelFormat,
+        shift: u32,
+        mask: u32,
+        a3: u32,
+    );
+    pub fn sceGuOffset(x: u32, y: u32);
+    pub fn sceGuScissor(x: i32, y: i32, w: i32, h: i32);
+    pub fn sceGuViewport(cx: i32, cy: i32, width: i32, height: i32);
+    pub fn sceGuDrawBezier(
+        v_type: i32,
+        u_count: i32,
+        v_count: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+    pub fn sceGuPatchDivide(ulevel: u32, vlevel: u32);
+
+    pub fn sceGuPatchFrontFace(a0: u32);
+    pub fn sceGuPatchPrim(prim: PatchPrimitive);
+
+    pub fn sceGuDrawSpline(
+        v_type: i32,
+        u_count: i32,
+        v_count: i32,
+        u_edge: i32,
+        v_edge: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+    pub fn sceGuSetMatrix(type_: MatrixMode, matrix: &ScePspFMatrix4);
+    pub fn sceGuBoneMatrix(index: u32, matrix: &ScePspFMatrix4);
+    pub fn sceGuMorphWeight(index: i32, weight: f32);
+    pub fn sceGuDrawArrayN(
+        primitive_type: GuPrimitive,
+        v_type: i32,
+        count: i32,
+        a3: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+}
+
+extern "C" {
+    pub fn sceGumDrawArray(
+        prim: GuPrimitive,
+        v_type: i32,
+        count: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+
+    pub fn sceGumDrawArrayN(
+        prim: GuPrimitive,
+        v_type: i32,
+        count: i32,
+        a3: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+
+    pub fn sceGumDrawBezier(
+        v_type: i32,
+        u_count: i32,
+        v_count: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+
+    pub fn sceGumDrawSpline(
+        v_type: i32,
+        u_count: i32,
+        v_count: i32,
+        u_edge: i32,
+        v_edge: i32,
+        indices: *const c_void,
+        vertices: *const c_void,
+    );
+
+    pub fn sceGumFastInverse();
+    pub fn sceGumFullInverse();
+    pub fn sceGumLoadIdentity();
+    pub fn sceGumLoadMatrix(m: &ScePspFMatrix4);
+    pub fn sceGumLookAt(
+        eye: &ScePspFVector3,
+        center: &ScePspFVector3,
+        up: &ScePspFVector3,
+    );
+    pub fn sceGumMatrixMode(mode: MatrixMode);
+    pub fn sceGumMultMatrix(m: &ScePspFMatrix4);
+    pub fn sceGumOrtho(
+        left: f32,
+        right: f32,
+        bottom: f32,
+        top: f32,
+        near: f32,
+        far: f32,
+    );
+    pub fn sceGumPerspective(fovy: f32, aspect: f32, near: f32, far: f32);
+    pub fn sceGumPopMatrix();
+    pub fn sceGumPushMatrix();
+    pub fn sceGumRotateX(angle: f32);
+    pub fn sceGumRotateY(angle: f32);
+    pub fn sceGumRotateZ(angle: f32);
+    pub fn sceGumRotateXYZ(v: &ScePspFVector3);
+    pub fn sceGumRotateZYX(v: &ScePspFVector3);
+    pub fn sceGumScale(v: &ScePspFVector3);
+    pub fn sceGumStoreMatrix(m: &mut ScePspFMatrix4);
+    pub fn sceGumTranslate(v: &ScePspFVector3);
+    pub fn sceGumUpdateMatrix();
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspSRect {
+    pub x: i16,
+    pub y: i16,
+    pub w: i16,
+    pub h: i16,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIRect {
+    pub x: i32,
+    pub y: i32,
+    pub w: i32,
+    pub h: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspL64Rect {
+    pub x: u64,
+    pub y: u64,
+    pub w: u64,
+    pub h: u64,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspFRect {
+    pub x: f32,
+    pub y: f32,
+    pub w: f32,
+    pub h: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspSVector2 {
+    pub x: i16,
+    pub y: i16,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIVector2 {
+    pub x: i32,
+    pub y: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspL64Vector2 {
+    pub x: u64,
+    pub y: u64,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspFVector2 {
+    pub x: f32,
+    pub y: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ScePspVector2 {
+    pub fv: ScePspFVector2,
+    pub iv: ScePspIVector2,
+    pub f: [f32; 2usize],
+    pub i: [i32; 2usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspSVector3 {
+    pub x: i16,
+    pub y: i16,
+    pub z: i16,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIVector3 {
+    pub x: i32,
+    pub y: i32,
+    pub z: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspL64Vector3 {
+    pub x: u64,
+    pub y: u64,
+    pub z: u64,
+}
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub struct ScePspFVector3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ScePspVector3 {
+    pub fv: ScePspFVector3,
+    pub iv: ScePspIVector3,
+    pub f: [f32; 3usize],
+    pub i: [i32; 3usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspSVector4 {
+    pub x: i16,
+    pub y: i16,
+    pub z: i16,
+    pub w: i16,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIVector4 {
+    pub x: i32,
+    pub y: i32,
+    pub z: i32,
+    pub w: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspL64Vector4 {
+    pub x: u64,
+    pub y: u64,
+    pub z: u64,
+    pub w: u64,
+}
+
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub struct ScePspFVector4 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspFVector4Unaligned {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+}
+
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub union ScePspVector4 {
+    pub fv: ScePspFVector4,
+    pub iv: ScePspIVector4,
+    pub qw: u128,
+    pub f: [f32; 4usize],
+    pub i: [i32; 4usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIMatrix2 {
+    pub x: ScePspIVector2,
+    pub y: ScePspIVector2,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspFMatrix2 {
+    pub x: ScePspFVector2,
+    pub y: ScePspFVector2,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ScePspMatrix2 {
+    pub fm: ScePspFMatrix2,
+    pub im: ScePspIMatrix2,
+    pub fv: [ScePspFVector2; 2usize],
+    pub iv: [ScePspIVector2; 2usize],
+    pub v: [ScePspVector2; 2usize],
+    pub f: [[f32; 2usize]; 2usize],
+    pub i: [[i32; 2usize]; 2usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIMatrix3 {
+    pub x: ScePspIVector3,
+    pub y: ScePspIVector3,
+    pub z: ScePspIVector3,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspFMatrix3 {
+    pub x: ScePspFVector3,
+    pub y: ScePspFVector3,
+    pub z: ScePspFVector3,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ScePspMatrix3 {
+    pub fm: ScePspFMatrix3,
+    pub im: ScePspIMatrix3,
+    pub fv: [ScePspFVector3; 3usize],
+    pub iv: [ScePspIVector3; 3usize],
+    pub v: [ScePspVector3; 3usize],
+    pub f: [[f32; 3usize]; 3usize],
+    pub i: [[i32; 3usize]; 3usize],
+}
+
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub struct ScePspIMatrix4 {
+    pub x: ScePspIVector4,
+    pub y: ScePspIVector4,
+    pub z: ScePspIVector4,
+    pub w: ScePspIVector4,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspIMatrix4Unaligned {
+    pub x: ScePspIVector4,
+    pub y: ScePspIVector4,
+    pub z: ScePspIVector4,
+    pub w: ScePspIVector4,
+}
+
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub struct ScePspFMatrix4 {
+    pub x: ScePspFVector4,
+    pub y: ScePspFVector4,
+    pub z: ScePspFVector4,
+    pub w: ScePspFVector4,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ScePspFMatrix4Unaligned {
+    pub x: ScePspFVector4,
+    pub y: ScePspFVector4,
+    pub z: ScePspFVector4,
+    pub w: ScePspFVector4,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ScePspMatrix4 {
+    pub fm: ScePspFMatrix4,
+    pub im: ScePspIMatrix4,
+    pub fv: [ScePspFVector4; 4usize],
+    pub iv: [ScePspIVector4; 4usize],
+    pub v: [ScePspVector4; 4usize],
+    pub f: [[f32; 4usize]; 4usize],
+    pub i: [[i32; 4usize]; 4usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceMp3InitArg {
+    pub mp3_stream_start: u32,
+    pub unk1: u32,
+    pub mp3_stream_end: u32,
+    pub unk2: u32,
+    pub mp3_buf: *mut c_void,
+    pub mp3_buf_size: i32,
+    pub pcm_buf: *mut c_void,
+    pub pcm_buf_size: i32,
+}
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Mp3Handle(pub i32);
+
+extern "C" {
+    pub fn sceMp3ReserveMp3Handle(args: *mut SceMp3InitArg) -> i32;
+    pub fn sceMp3ReleaseMp3Handle(handle: Mp3Handle) -> i32;
+    pub fn sceMp3InitResource() -> i32;
+    pub fn sceMp3TermResource() -> i32;
+    pub fn sceMp3Init(handle: Mp3Handle) -> i32;
+    pub fn sceMp3Decode(handle: Mp3Handle, dst: *mut *mut i16) -> i32;
+    pub fn sceMp3GetInfoToAddStreamData(
+        handle: Mp3Handle,
+        dst: *mut *mut u8,
+        to_write: *mut i32,
+        src_pos: *mut i32,
+    ) -> i32;
+    pub fn sceMp3NotifyAddStreamData(handle: Mp3Handle, size: i32) -> i32;
+    pub fn sceMp3CheckStreamDataNeeded(handle: Mp3Handle) -> i32;
+    pub fn sceMp3SetLoopNum(handle: Mp3Handle, loop_: i32) -> i32;
+    pub fn sceMp3GetLoopNum(handle: Mp3Handle) -> i32;
+    pub fn sceMp3GetSumDecodedSample(handle: Mp3Handle) -> i32;
+    pub fn sceMp3GetMaxOutputSample(handle: Mp3Handle) -> i32;
+    pub fn sceMp3GetSamplingRate(handle: Mp3Handle) -> i32;
+    pub fn sceMp3GetBitRate(handle: Mp3Handle) -> i32;
+    pub fn sceMp3GetMp3ChannelNum(handle: Mp3Handle) -> i32;
+    pub fn sceMp3ResetPlayPosition(handle: Mp3Handle) -> i32;
+}
+
+#[repr(transparent)]
+#[allow(missing_copy_implementations)]
+pub struct RegHandle(u32);
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Key {
+    pub key_type: KeyType,
+    pub name: [u8; 256usize],
+    pub name_len: u32,
+    pub unk2: u32,
+    pub unk3: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub enum KeyType {
+    Directory = 1,
+    Integer = 2,
+    String = 3,
+    Bytes = 4,
+}
+
+extern "C" {
+    pub fn sceRegOpenRegistry(
+        reg: *mut Key,
+        mode: i32,
+        handle: *mut RegHandle,
+    ) -> i32;
+    pub fn sceRegFlushRegistry(handle: RegHandle) -> i32;
+    pub fn sceRegCloseRegistry(handle: RegHandle) -> i32;
+    pub fn sceRegOpenCategory(
+        handle: RegHandle,
+        name: *const u8,
+        mode: i32,
+        dir_handle: *mut RegHandle,
+    ) -> i32;
+    pub fn sceRegRemoveCategory(
+        handle: RegHandle,
+        name: *const u8,
+    ) -> i32;
+    pub fn sceRegCloseCategory(dir_handle: RegHandle) -> i32;
+    pub fn sceRegFlushCategory(dir_handle: RegHandle) -> i32;
+    pub fn sceRegGetKeyInfo(
+        dir_handle: RegHandle,
+        name: *const u8,
+        key_handle: *mut RegHandle,
+        type_: *mut KeyType,
+        size: *mut usize,
+    ) -> i32;
+    pub fn sceRegGetKeyInfoByName(
+        dir_handle: RegHandle,
+        name: *const u8,
+        type_: *mut KeyType,
+        size: *mut usize,
+    ) -> i32;
+    pub fn sceRegGetKeyValue(
+        dir_handle: RegHandle,
+        key_handle: RegHandle,
+        buf: *mut c_void,
+        size: usize,
+    ) -> i32;
+    pub fn sceRegGetKeyValueByName(
+        dir_handle: RegHandle,
+        name: *const u8,
+        buf: *mut c_void,
+        size: usize,
+    ) -> i32;
+    pub fn sceRegSetKeyValue(
+        dir_handle: RegHandle,
+        name: *const u8,
+        buf: *const c_void,
+        size: usize,
+    ) -> i32;
+    pub fn sceRegGetKeysNum(
+        dir_handle: RegHandle,
+        num: *mut i32,
+    ) -> i32;
+    pub fn sceRegGetKeys(
+        dir_handle: RegHandle,
+        buf: *mut u8,
+        num: i32,
+    ) -> i32;
+    pub fn sceRegCreateKey(
+        dir_handle: RegHandle,
+        name: *const u8,
+        type_: i32,
+        size: usize,
+    ) -> i32;
+    pub fn sceRegRemoveRegistry(key: *mut Key) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct OpenPSID {
+    pub data: [u8; 16usize],
+}
+
+extern "C" {
+    pub fn sceOpenPSIDGetOpenPSID(openpsid: *mut OpenPSID) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilityDialogCommon {
+    pub size: u32,
+    pub language: SystemParamLanguage,
+    pub button_accept: UtilityDialogButtonAccept,
+    pub graphics_thread: i32,
+    pub access_thread: i32,
+    pub font_thread: i32,
+    pub sound_thread: i32,
+    pub result: i32,
+    pub reserved: [i32; 4usize],
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityMsgDialogMode {
+    Error,
+    Text,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityMsgDialogPressed {
+    Unknown1,
+    Yes,
+    No,
+    Back,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityDialogButtonAccept {
+    Circle,
+    Cross,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SceUtilityOskInputLanguage {
+    Default,
+    Japanese,
+    English,
+    French,
+    Spanish,
+    German,
+    Italian,
+    Dutch,
+    Portugese,
+    Russian,
+    Korean,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SceUtilityOskInputType {
+    All,
+    LatinDigit,
+    LatinSymbol,
+    LatinLowercase = 4,
+    LatinUppercase = 8,
+    JapaneseDigit = 0x100,
+    JapaneseSymbol = 0x200,
+    JapaneseLowercase = 0x400,
+    JapaneseUppercase = 0x800,
+    JapaneseHiragana = 0x1000,
+    JapaneseHalfWidthKatakana = 0x2000,
+    JapaneseKatakana = 0x4000,
+    JapaneseKanji = 0x8000,
+    RussianLowercase = 0x10000,
+    RussianUppercase = 0x20000,
+    Korean = 0x40000,
+    Url = 0x80000,
+}
+
+#[derive(Clone, Copy)]
+pub enum SceUtilityOskState {
+    None,
+    Initializing,
+    Initialized,
+    Visible,
+    Quit,
+    Finished,
+}
+
+#[derive(Clone, Copy)]
+pub enum SceUtilityOskResult {
+    Unchanged,
+    Cancelled,
+    Changed,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamLanguage {
+    Japanese,
+    English,
+    French,
+    Spanish,
+    German,
+    Italian,
+    Dutch,
+    Portugese,
+    Russian,
+    Korean,
+    ChineseTraditional,
+    ChineseSimplified,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamId {
+    StringNickname = 1,
+    AdhocChannel,
+    WlanPowerSave,
+    DateFormat,
+    TimeFormat,
+    Timezone,
+    DaylightSavings,
+    Language,
+    Unknown,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamAdhocChannel {
+    ChannelAutomatic = 0,
+    Channel1 = 1,
+    Channel6 = 6,
+    Channel11 = 11,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamWlanPowerSaveState {
+    Off,
+    On,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamDateFormat {
+    YYYYMMDD,
+    MMDDYYYY,
+    DDMMYYYY,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamTimeFormat {
+    Hour24,
+    Hour12,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum SystemParamDaylightSavings {
+    Std,
+    Dst,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum AvModule {
+    AvCodec,
+    SasCore,
+    Atrac3Plus,
+    MpegBase,
+    Mp3,
+    Vaudio,
+    Aac,
+    G729,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum Module {
+    NetCommon = 0x100,
+    NetAdhoc,
+    NetInet,
+    NetParseUri,
+    NetHttp,
+    NetSsl,
+
+    UsbPspCm = 0x200,
+    UsbMic,
+    UsbCam,
+    UsbGps,
+
+    AvCodec = 0x300,
+    AvSascore,
+    AvAtrac3Plus,
+    AvMpegBase,
+    AvMp3,
+    AvVaudio,
+    AvAac,
+    AvG729,
+
+    NpCommon = 0x400,
+    NpService,
+    NpMatching2,
+    NpDrm = 0x500,
+
+    Irda = 0x600,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum NetModule {
+    NetCommon = 1,
+    NetAdhoc,
+    NetInet,
+    NetParseUri,
+    NetHttp,
+    NetSsl,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UsbModule {
+    UsbPspCm = 1,
+    UsbAcc,
+    UsbMic,
+    UsbCam,
+    UsbGps,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum NetParam {
+    Name,
+    Ssid,
+    Secure,
+    WepKey,
+    IsStaticIp,
+    Ip,
+    NetMask,
+    Route,
+    ManualDns,
+    PrimaryDns,
+    SecondaryDns,
+    ProxyUser,
+    ProxyPass,
+    UseProxy,
+    ProxyServer,
+    ProxyPort,
+    Unknown1,
+    Unknown2,
+}
+
+#[derive(Copy, Clone)]
+pub enum UtilityNetconfAction {
+    ConnectAP,
+    DisplayStatus,
+    ConnectAdhoc,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilityMsgDialogParams {
+    pub base: UtilityDialogCommon,
+    pub unknown: i32,
+    pub mode: UtilityMsgDialogMode,
+    pub error_value: u32,
+    pub message: [u8; 512usize],
+    pub options: i32,
+    pub button_pressed: UtilityMsgDialogPressed,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilityNetconfAdhoc {
+    pub name: [u8; 8usize],
+    pub timeout: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilityNetconfData {
+    pub base: UtilityDialogCommon,
+    pub action: UtilityNetconfAction,
+    pub adhocparam: *mut UtilityNetconfAdhoc,
+    pub hotspot: i32,
+    pub hotspot_connected: i32,
+    pub wifisp: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union UtilityNetData {
+    pub as_uint: u32,
+    pub as_string: [u8; 128usize],
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum UtilitySavedataMode {
+    AutoLoad,
+    AutoSave,
+    Load,
+    Save,
+    ListLoad,
+    ListSave,
+    ListDelete,
+    Delete,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum UtilitySavedataFocus {
+    Unknown1,
+    FirstList,
+    LastList,
+    Latest,
+    Oldest,
+    Unknown2,
+    Unknown3,
+    FirstEmpty,
+    LastEmpty,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilitySavedataSFOParam {
+    pub title: [u8; 128usize],
+    pub savedata_title: [u8; 128usize],
+    pub detail: [u8; 1024usize],
+    pub parental_level: u8,
+    pub unknown: [u8; 3usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilitySavedataFileData {
+    pub buf: *mut c_void,
+    pub buf_size: usize,
+    pub size: usize,
+    pub unknown: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilitySavedataListSaveNewData {
+    pub icon0: UtilitySavedataFileData,
+    pub title: *mut u8,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceUtilitySavedataParam {
+    pub base: UtilityDialogCommon,
+    pub mode: UtilitySavedataMode,
+    pub unknown1: i32,
+    pub overwrite: i32,
+    pub game_name: [u8; 13usize],
+    pub reserved: [u8; 3usize],
+    pub save_name: [u8; 20usize],
+    pub save_name_list: *mut [u8; 20usize],
+    pub file_name: [u8; 13usize],
+    pub reserved1: [u8; 3usize],
+    pub data_buf: *mut c_void,
+    pub data_buf_size: usize,
+    pub data_size: usize,
+    pub sfo_param: UtilitySavedataSFOParam,
+    pub icon0_file_data: UtilitySavedataFileData,
+    pub icon1_file_data: UtilitySavedataFileData,
+    pub pic1_file_data: UtilitySavedataFileData,
+    pub snd0_file_data: UtilitySavedataFileData,
+    pub new_data: *mut UtilitySavedataListSaveNewData,
+    pub focus: UtilitySavedataFocus,
+    pub unknown2: [i32; 4usize],
+    pub key: [u8; 16],
+    pub unknown3: [u8; 20],
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum UtilityGameSharingMode {
+    Single = 1,
+    Multiple,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum UtilityGameSharingDataType {
+    File = 1,
+    Memory,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilityGameSharingParams {
+    pub base: UtilityDialogCommon,
+    pub unknown1: i32,
+    pub unknown2: i32,
+    pub name: [u8; 8usize],
+    pub unknown3: i32,
+    pub unknown4: i32,
+    pub unknown5: i32,
+    pub result: i32,
+    pub filepath: *mut u8,
+    pub mode: UtilityGameSharingMode,
+    pub datatype: UtilityGameSharingDataType,
+    pub data: *mut c_void,
+    pub datasize: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UtilityHtmlViewerParam {
+    pub base: UtilityDialogCommon,
+    pub memaddr: *mut c_void,
+    pub memsize: u32,
+    pub unknown1: i32,
+    pub unknown2: i32,
+    pub initialurl: *mut u8,
+    pub numtabs: u32,
+    pub interfacemode: UtilityHtmlViewerInterfaceMode,
+    pub options: i32,
+    pub dldirname: *mut u8,
+    pub dlfilename: *mut u8,
+    pub uldirname: *mut u8,
+    pub ulfilename: *mut u8,
+    pub cookiemode: UtilityHtmlViewerCookieMode,
+    pub unknown3: u32,
+    pub homeurl: *mut u8,
+    pub textsize: UtilityHtmlViewerTextSize,
+    pub displaymode: UtilityHtmlViewerDisplayMode,
+    pub connectmode: UtilityHtmlViewerConnectMode,
+    pub disconnectmode: UtilityHtmlViewerDisconnectMode,
+    pub memused: u32,
+    pub unknown4: [i32; 10usize],
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityHtmlViewerInterfaceMode {
+    Full,
+    Limited,
+    None,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityHtmlViewerCookieMode {
+    Disabled = 0,
+    Enabled,
+    Confirm,
+    Default,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityHtmlViewerTextSize {
+    Large,
+    Normal,
+    Small,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityHtmlViewerDisplayMode {
+    Normal,
+    Fit,
+    SmartFit,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityHtmlViewerConnectMode {
+    Last,
+    ManualOnce,
+    ManualAll,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum UtilityHtmlViewerDisconnectMode {
+    Enable,
+    Disable,
+    Confirm,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceUtilityOskData {
+    pub unk_00: i32,
+    pub unk_04: i32,
+    pub language: SceUtilityOskInputLanguage,
+    pub unk_12: i32,
+    pub inputtype: SceUtilityOskInputType,
+    pub lines: i32,
+    pub unk_24: i32,
+    pub desc: *mut u16,
+    pub intext: *mut u16,
+    pub outtextlength: i32,
+    pub outtext: *mut u16,
+    pub result: SceUtilityOskResult,
+    pub outtextlimit: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceUtilityOskParams {
+    pub base: UtilityDialogCommon,
+    pub datacount: i32,
+    pub data: *mut SceUtilityOskData,
+    pub state: SceUtilityOskState,
+    pub unk_60: i32,
+}
+
+extern "C" {
+    pub fn sceUtilityMsgDialogInitStart(
+        params: *mut UtilityMsgDialogParams,
+    ) -> i32;
+    pub fn sceUtilityMsgDialogShutdownStart();
+    pub fn sceUtilityMsgDialogGetStatus() -> i32;
+    pub fn sceUtilityMsgDialogUpdate(n: i32);
+    pub fn sceUtilityMsgDialogAbort() -> i32;
+    pub fn sceUtilityNetconfInitStart(data: *mut UtilityNetconfData) -> i32;
+    pub fn sceUtilityNetconfShutdownStart() -> i32;
+    pub fn sceUtilityNetconfUpdate(unknown: i32) -> i32;
+    pub fn sceUtilityNetconfGetStatus() -> i32;
+    pub fn sceUtilityCheckNetParam(id: i32) -> i32;
+    pub fn sceUtilityGetNetParam(
+        conf: i32,
+        param: NetParam,
+        data: *mut UtilityNetData,
+    ) -> i32;
+    pub fn sceUtilitySavedataInitStart(
+        params: *mut SceUtilitySavedataParam,
+    ) -> i32;
+    pub fn sceUtilitySavedataGetStatus() -> i32;
+    pub fn sceUtilitySavedataShutdownStart() -> i32;
+    pub fn sceUtilitySavedataUpdate(unknown: i32);
+    pub fn sceUtilityGameSharingInitStart(
+        params: *mut UtilityGameSharingParams,
+    ) -> i32;
+    pub fn sceUtilityGameSharingShutdownStart();
+    pub fn sceUtilityGameSharingGetStatus() -> i32;
+    pub fn sceUtilityGameSharingUpdate(n: i32);
+    pub fn sceUtilityHtmlViewerInitStart(
+        params: *mut UtilityHtmlViewerParam,
+    ) -> i32;
+    pub fn sceUtilityHtmlViewerShutdownStart() -> i32;
+    pub fn sceUtilityHtmlViewerUpdate(n: i32) -> i32;
+    pub fn sceUtilityHtmlViewerGetStatus() -> i32;
+    pub fn sceUtilitySetSystemParamInt(id: SystemParamId, value: i32) -> i32;
+    pub fn sceUtilitySetSystemParamString(
+        id: SystemParamId,
+        str: *const u8,
+    ) -> i32;
+    pub fn sceUtilityGetSystemParamInt(
+        id: SystemParamId,
+        value: *mut i32,
+    ) -> i32;
+    pub fn sceUtilityGetSystemParamString(
+        id: SystemParamId,
+        str: *mut u8,
+        len: i32,
+    ) -> i32;
+    pub fn sceUtilityOskInitStart(params: *mut SceUtilityOskParams) -> i32;
+    pub fn sceUtilityOskShutdownStart() -> i32;
+    pub fn sceUtilityOskUpdate(n: i32) -> i32;
+    pub fn sceUtilityOskGetStatus() -> i32;
+    pub fn sceUtilityLoadNetModule(module: NetModule) -> i32;
+    pub fn sceUtilityUnloadNetModule(module: NetModule) -> i32;
+    pub fn sceUtilityLoadAvModule(module: AvModule) -> i32;
+    pub fn sceUtilityUnloadAvModule(module: AvModule) -> i32;
+    pub fn sceUtilityLoadUsbModule(module: UsbModule) -> i32;
+    pub fn sceUtilityUnloadUsbModule(module: UsbModule) -> i32;
+    pub fn sceUtilityLoadModule(module: Module) -> i32;
+    pub fn sceUtilityUnloadModule(module: Module) -> i32;
+}
+
+extern "C" {
+    pub fn sceUtilityCreateNetParam(conf: i32) -> i32;
+    pub fn sceUtilitySetNetParam(param: NetParam, val: *const c_void) -> i32;
+    pub fn sceUtilityCopyNetParam(src: i32, dest: i32) -> i32;
+    pub fn sceUtilityDeleteNetParam(conf: i32) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetMallocStat {
+    pub pool: i32,
+    pub maximum: i32,
+    pub free: i32,
+}
+
+extern "C" {
+    pub fn sceNetInit(
+        poolsize: i32,
+        calloutprio: i32,
+        calloutstack: i32,
+        netintrprio: i32,
+        netintrstack: i32,
+    ) -> i32;
+    pub fn sceNetTerm() -> i32;
+    pub fn sceNetFreeThreadinfo(thid: i32) -> i32;
+    pub fn sceNetThreadAbort(thid: i32) -> i32;
+    pub fn sceNetEtherStrton(name: *mut u8, mac: *mut u8);
+    pub fn sceNetEtherNtostr(mac: *mut u8, name: *mut u8);
+    pub fn sceNetGetLocalEtherAddr(mac: *mut u8) -> i32;
+    pub fn sceNetGetMallocStat(stat: *mut SceNetMallocStat) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocctlAdhocId {
+    pub unknown: i32,
+    pub adhoc_id: [u8; 9usize],
+    pub unk: [u8; 3usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocctlPeerInfo {
+    pub next: *mut SceNetAdhocctlPeerInfo,
+    pub nickname: [u8; 128usize],
+    pub mac: [u8; 6usize],
+    pub unknown: [u8; 6usize],
+    pub timestamp: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocctlScanInfo {
+    pub next: *mut SceNetAdhocctlScanInfo,
+    pub channel: i32,
+    pub name: [u8; 8usize],
+    pub bssid: [u8; 6usize],
+    pub unknown: [u8; 2usize],
+    pub unknown2: i32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocctlGameModeInfo {
+    pub count: i32,
+    pub macs: [[u8; 6usize]; 16usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocctlParams {
+    pub channel: i32,
+    pub name: [u8; 8usize],
+    pub bssid: [u8; 6usize],
+    pub nickname: [u8; 128usize],
+}
+
+extern "C" {
+    pub fn sceNetAdhocctlInit(
+        stacksize: i32,
+        priority: i32,
+        adhoc_id: *mut SceNetAdhocctlAdhocId,
+    ) -> i32;
+    pub fn sceNetAdhocctlTerm() -> i32;
+    pub fn sceNetAdhocctlConnect(name: *const u8) -> i32;
+    pub fn sceNetAdhocctlDisconnect() -> i32;
+    pub fn sceNetAdhocctlGetState(event: *mut i32) -> i32;
+    pub fn sceNetAdhocctlCreate(name: *const u8) -> i32;
+    pub fn sceNetAdhocctlJoin(scaninfo: *mut SceNetAdhocctlScanInfo) -> i32;
+    pub fn sceNetAdhocctlGetAdhocId(id: *mut SceNetAdhocctlAdhocId) -> i32;
+    pub fn sceNetAdhocctlCreateEnterGameMode(
+        name: *const u8,
+        unknown: i32,
+        num: i32,
+        macs: *mut u8,
+        timeout: u32,
+        unknown2: i32,
+    ) -> i32;
+    pub fn sceNetAdhocctlJoinEnterGameMode(
+        name: *const u8,
+        hostmac: *mut u8,
+        timeout: u32,
+        unknown: i32,
+    ) -> i32;
+    pub fn sceNetAdhocctlGetGameModeInfo(
+        gamemodeinfo: *mut SceNetAdhocctlGameModeInfo,
+    ) -> i32;
+    pub fn sceNetAdhocctlExitGameMode() -> i32;
+    pub fn sceNetAdhocctlGetPeerList(
+        length: *mut i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocctlGetPeerInfo(
+        mac: *mut u8,
+        size: i32,
+        peerinfo: *mut SceNetAdhocctlPeerInfo,
+    ) -> i32;
+    pub fn sceNetAdhocctlScan() -> i32;
+    pub fn sceNetAdhocctlGetScanInfo(
+        length: *mut i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocctlAddHandler(
+        handler: SceNetAdhocctlHandler,
+        unknown: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocctlDelHandler(id: i32) -> i32;
+    pub fn sceNetAdhocctlGetNameByAddr(mac: *mut u8, nickname: *mut u8)
+        -> i32;
+    pub fn sceNetAdhocctlGetAddrByName(
+        nickname: *mut u8,
+        length: *mut i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocctlGetParameter(
+        params: *mut SceNetAdhocctlParams,
+    ) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocPtpStat {
+    pub next: *mut SceNetAdhocPtpStat,
+    pub ptp_id: i32,
+    pub mac: [u8; 6usize],
+    pub peermac: [u8; 6usize],
+    pub port: u16,
+    pub peerport: u16,
+    pub sent_data: u32,
+    pub rcvd_data: u32,
+    pub state: ScePspnetAdhocPtpState,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum ScePspnetAdhocPtpState {
+    Closed,
+    Listen,
+    SynSent,
+    SynReceived,
+    Established,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SceNetAdhocPdpStat {
+    pub next: *mut SceNetAdhocPdpStat,
+    pub pdp_id: i32,
+    pub mac: [u8; 6usize],
+    pub port: u16,
+    pub rcvd_data: u32,
+}
+
+extern "C" {
+    pub fn sceNetAdhocInit() -> i32;
+    pub fn sceNetAdhocTerm() -> i32;
+    pub fn sceNetAdhocPdpCreate(
+        mac: *mut u8,
+        port: u16,
+        buf_size: u32,
+        unk1: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPdpDelete(id: i32, unk1: i32) -> i32;
+    pub fn sceNetAdhocPdpSend(
+        id: i32,
+        dest_mac_addr: *mut u8,
+        port: u16,
+        data: *mut c_void,
+        len: u32,
+        timeout: u32,
+        nonblock: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPdpRecv(
+        id: i32,
+        src_mac_addr: *mut u8,
+        port: *mut u16,
+        data: *mut c_void,
+        data_length: *mut c_void,
+        timeout: u32,
+        nonblock: i32,
+    ) -> i32;
+    pub fn sceNetAdhocGetPdpStat(
+        size: *mut i32,
+        stat: *mut SceNetAdhocPdpStat,
+    ) -> i32;
+    pub fn sceNetAdhocGameModeCreateMaster(
+        data: *mut c_void,
+        size: i32,
+    ) -> i32;
+    pub fn sceNetAdhocGameModeCreateReplica(
+        mac: *mut u8,
+        data: *mut c_void,
+        size: i32,
+    ) -> i32;
+    pub fn sceNetAdhocGameModeUpdateMaster() -> i32;
+    pub fn sceNetAdhocGameModeUpdateReplica(id: i32, unk1: i32) -> i32;
+    pub fn sceNetAdhocGameModeDeleteMaster() -> i32;
+    pub fn sceNetAdhocGameModeDeleteReplica(id: i32) -> i32;
+    pub fn sceNetAdhocPtpOpen(
+        srcmac: *mut u8,
+        srcport: u16,
+        destmac: *mut u8,
+        destport: u16,
+        buf_size: u32,
+        delay: u32,
+        count: i32,
+        unk1: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPtpConnect(id: i32, timeout: u32, nonblock: i32) -> i32;
+    pub fn sceNetAdhocPtpListen(
+        srcmac: *mut u8,
+        srcport: u16,
+        buf_size: u32,
+        delay: u32,
+        count: i32,
+        queue: i32,
+        unk1: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPtpAccept(
+        id: i32,
+        mac: *mut u8,
+        port: *mut u16,
+        timeout: u32,
+        nonblock: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPtpSend(
+        id: i32,
+        data: *mut c_void,
+        data_size: *mut i32,
+        timeout: u32,
+        nonblock: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPtpRecv(
+        id: i32,
+        data: *mut c_void,
+        data_size: *mut i32,
+        timeout: u32,
+        nonblock: i32,
+    ) -> i32;
+    pub fn sceNetAdhocPtpFlush(id: i32, timeout: u32, nonblock: i32) -> i32;
+    pub fn sceNetAdhocPtpClose(id: i32, unk1: i32) -> i32;
+    pub fn sceNetAdhocGetPtpStat(
+        size: *mut i32,
+        stat: *mut SceNetAdhocPtpStat,
+    ) -> i32;
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct AdhocPoolStat {
+    pub size: i32,
+    pub maxsize: i32,
+    pub freesize: i32,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum AdhocMatchingMode {
+    Host = 1,
+    Client,
+    Ptp,
+}
+
+extern "C" {
+    pub fn sceNetAdhocMatchingInit(memsize: i32) -> i32;
+    pub fn sceNetAdhocMatchingTerm() -> i32;
+    pub fn sceNetAdhocMatchingCreate(
+        mode: AdhocMatchingMode,
+        max_peers: i32,
+        port: u16,
+        buf_size: i32,
+        hello_delay: u32,
+        ping_delay: u32,
+        init_count: i32,
+        msg_delay: u32,
+        callback: AdhocMatchingCallback,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingDelete(matching_id: i32) -> i32;
+    pub fn sceNetAdhocMatchingStart(
+        matching_id: i32,
+        evth_pri: i32,
+        evth_stack: i32,
+        inth_pri: i32,
+        inth_stack: i32,
+        opt_len: i32,
+        opt_data: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingStop(matching_id: i32) -> i32;
+    pub fn sceNetAdhocMatchingSelectTarget(
+        matching_id: i32,
+        mac: *mut u8,
+        opt_len: i32,
+        opt_data: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingCancelTarget(
+        matching_id: i32,
+        mac: *mut u8,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingCancelTargetWithOpt(
+        matching_id: i32,
+        mac: *mut u8,
+        opt_len: i32,
+        opt_data: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingSendData(
+        matching_id: i32,
+        mac: *mut u8,
+        data_len: i32,
+        data: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingAbortSendData(
+        matching_id: i32,
+        mac: *mut u8,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingSetHelloOpt(
+        matching_id: i32,
+        opt_len: i32,
+        opt_data: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingGetHelloOpt(
+        matching_id: i32,
+        opt_len: *mut i32,
+        opt_data: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingGetMembers(
+        matching_id: i32,
+        length: *mut i32,
+        buf: *mut c_void,
+    ) -> i32;
+    pub fn sceNetAdhocMatchingGetPoolMaxAlloc() -> i32;
+    pub fn sceNetAdhocMatchingGetPoolStat(poolstat: *mut AdhocPoolStat)
+        -> i32;
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum ApctlState {
+    Disconnected,
+    Scanning,
+    Joining,
+    GettingIp,
+    GotIp,
+    EapAuth,
+    KeyExchange,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum ApctlEvent {
+    ConnectRequest,
+    ScanRequest,
+    ScanComplete,
+    Established,
+    GetIp,
+    DisconnectRequest,
+    Error,
+    Info,
+    EapAuth,
+    KeyExchange,
+    Reconnect,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum ApctlInfo {
+    ProfileName,
+    Bssid,
+    Ssid,
+    SsidLength,
+    SecurityType,
+    Strength,
+    Channel,
+    PowerSave,
+    Ip,
+    SubnetMask,
+    Gateway,
+    PrimaryDns,
+    SecondaryDns,
+    UseProxy,
+    ProxyUrl,
+    ProxyPort,
+    EapType,
+    StartBrowser,
+    Wifisp,
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy)]
+pub enum ApctlInfoSecurityType {
+    None,
+    Wep,
+    Wpa,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union SceNetApctlInfo {
+    pub name: [u8; 64usize],
+    pub bssid: [u8; 6usize],
+    pub ssid: [u8; 32usize],
+    pub ssid_length: u32,
+    pub security_type: u32,
+    pub strength: u8,
+    pub channel: u8,
+    pub power_save: u8,
+    pub ip: [u8; 16usize],
+    pub sub_net_mask: [u8; 16usize],
+    pub gateway: [u8; 16usize],
+    pub primary_dns: [u8; 16usize],
+    pub secondary_dns: [u8; 16usize],
+    pub use_proxy: u32,
+    pub proxy_url: [u8; 128usize],
+    pub proxy_port: u16,
+    pub eap_type: u32,
+    pub start_browser: u32,
+    pub wifisp: u32,
+}
+
+extern "C" {
+    pub fn sceNetApctlInit(stack_size: i32, init_priority: i32) -> i32;
+    pub fn sceNetApctlTerm() -> i32;
+    pub fn sceNetApctlGetInfo(
+        code: ApctlInfo,
+        pinfo: *mut SceNetApctlInfo,
+    ) -> i32;
+    pub fn sceNetApctlAddHandler(
+        handler: SceNetApctlHandler,
+        parg: *mut c_void,
+    ) -> i32;
+    pub fn sceNetApctlDelHandler(handler_id: i32) -> i32;
+    pub fn sceNetApctlConnect(conn_index: i32) -> i32;
+    pub fn sceNetApctlDisconnect() -> i32;
+    pub fn sceNetApctlGetState(pstate: *mut ApctlState) -> i32;
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct sockaddr(pub u32);
+
+extern "C" {
+    pub fn sceNetInetInit() -> i32;
+    pub fn sceNetInetTerm() -> i32;
+    pub fn sceNetInetAccept(
+        s: i32,
+        addr: *mut sockaddr,
+        addr_len: *mut socklen_t,
+    ) -> i32;
+    pub fn sceNetInetBind(
+        s: i32,
+        my_addr: *const sockaddr,
+        addr_len: socklen_t,
+    ) -> i32;
+    pub fn sceNetInetConnect(
+        s: i32,
+        serv_addr: *const sockaddr,
+        addr_len: socklen_t,
+    ) -> i32;
+    pub fn sceNetInetGetsockopt(
+        s: i32,
+        level: i32,
+        opt_name: i32,
+        opt_val: *mut c_void,
+        optl_en: *mut socklen_t,
+    ) -> i32;
+    pub fn sceNetInetListen(s: i32, backlog: i32) -> i32;
+    pub fn sceNetInetRecv(
+        s: i32,
+        buf: *mut c_void,
+        len: usize,
+        flags: i32,
+    ) -> usize;
+    pub fn sceNetInetRecvfrom(
+        s: i32,
+        buf: *mut c_void,
+        flags: usize,
+        arg1: i32,
+        from: *mut sockaddr,
+        from_len: *mut socklen_t,
+    ) -> usize;
+    pub fn sceNetInetSend(
+        s: i32,
+        buf: *const c_void,
+        len: usize,
+        flags: i32,
+    ) -> usize;
+    pub fn sceNetInetSendto(
+        s: i32,
+        buf: *const c_void,
+        len: usize,
+        flags: i32,
+        to: *const sockaddr,
+        to_len: socklen_t,
+    ) -> usize;
+    pub fn sceNetInetSetsockopt(
+        s: i32,
+        level: i32,
+        opt_name: i32,
+        opt_val: *const c_void,
+        opt_len: socklen_t,
+    ) -> i32;
+    pub fn sceNetInetShutdown(s: i32, how: i32) -> i32;
+    pub fn sceNetInetSocket(domain: i32, type_: i32, protocol: i32) -> i32;
+    pub fn sceNetInetClose(s: i32) -> i32;
+    pub fn sceNetInetGetErrno() -> i32;
+}
+
+extern "C" {
+    pub fn sceSslInit(unknown1: i32) -> i32;
+    pub fn sceSslEnd() -> i32;
+    pub fn sceSslGetUsedMemoryMax(memory: *mut u32) -> i32;
+    pub fn sceSslGetUsedMemoryCurrent(memory: *mut u32) -> i32;
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum HttpMethod {
+    Get,
+    Post,
+    Head,
+}
+
+#[repr(u32)]
+#[derive(Copy, Clone)]
+pub enum HttpAuthType {
+    Basic,
+    Digest,
+}
+
+extern "C" {
+    pub fn sceHttpInit(unknown1: u32) -> i32;
+    pub fn sceHttpEnd() -> i32;
+    pub fn sceHttpCreateTemplate(
+        agent: *mut u8,
+        unknown1: i32,
+        unknown2: i32,
+    ) -> i32;
+    pub fn sceHttpDeleteTemplate(templateid: i32) -> i32;
+    pub fn sceHttpCreateConnection(
+        templateid: i32,
+        host: *mut u8,
+        unknown1: *mut u8,
+        port: u16,
+        unknown2: i32,
+    ) -> i32;
+    pub fn sceHttpCreateConnectionWithURL(
+        templateid: i32,
+        url: *const u8,
+        unknown1: i32,
+    ) -> i32;
+    pub fn sceHttpDeleteConnection(connection_id: i32) -> i32;
+    pub fn sceHttpCreateRequest(
+        connection_id: i32,
+        method: HttpMethod,
+        path: *mut u8,
+        content_length: u64,
+    ) -> i32;
+    pub fn sceHttpCreateRequestWithURL(
+        connection_id: i32,
+        method: HttpMethod,
+        url: *mut u8,
+        content_length: u64,
+    ) -> i32;
+    pub fn sceHttpDeleteRequest(request_id: i32) -> i32;
+    pub fn sceHttpSendRequest(
+        request_id: i32,
+        data: *mut c_void,
+        data_size: u32,
+    ) -> i32;
+    pub fn sceHttpAbortRequest(request_id: i32) -> i32;
+    pub fn sceHttpReadData(
+        request_id: i32,
+        data: *mut c_void,
+        data_size: u32,
+    ) -> i32;
+    pub fn sceHttpGetContentLength(
+        request_id: i32,
+        content_length: *mut u64,
+    ) -> i32;
+    pub fn sceHttpGetStatusCode(request_id: i32, status_code: *mut i32)
+        -> i32;
+    pub fn sceHttpSetResolveTimeOut(id: i32, timeout: u32) -> i32;
+    pub fn sceHttpSetResolveRetry(id: i32, count: i32) -> i32;
+    pub fn sceHttpSetConnectTimeOut(id: i32, timeout: u32) -> i32;
+    pub fn sceHttpSetSendTimeOut(id: i32, timeout: u32) -> i32;
+    pub fn sceHttpSetRecvTimeOut(id: i32, timeout: u32) -> i32;
+    pub fn sceHttpEnableKeepAlive(id: i32) -> i32;
+    pub fn sceHttpDisableKeepAlive(id: i32) -> i32;
+    pub fn sceHttpEnableRedirect(id: i32) -> i32;
+    pub fn sceHttpDisableRedirect(id: i32) -> i32;
+    pub fn sceHttpEnableCookie(id: i32) -> i32;
+    pub fn sceHttpDisableCookie(id: i32) -> i32;
+    pub fn sceHttpSaveSystemCookie() -> i32;
+    pub fn sceHttpLoadSystemCookie() -> i32;
+    pub fn sceHttpAddExtraHeader(
+        id: i32,
+        name: *mut u8,
+        value: *mut u8,
+        unknown1: i32,
+    ) -> i32;
+    pub fn sceHttpDeleteHeader(id: i32, name: *const u8) -> i32;
+    pub fn sceHttpsInit(
+        unknown1: i32,
+        unknown2: i32,
+        unknown3: i32,
+        unknown4: i32,
+    ) -> i32;
+    pub fn sceHttpsEnd() -> i32;
+    pub fn sceHttpsLoadDefaultCert(unknown1: i32, unknown2: i32) -> i32;
+    pub fn sceHttpDisableAuth(id: i32) -> i32;
+    pub fn sceHttpDisableCache(id: i32) -> i32;
+    pub fn sceHttpEnableAuth(id: i32) -> i32;
+    pub fn sceHttpEnableCache(id: i32) -> i32;
+    pub fn sceHttpEndCache() -> i32;
+    pub fn sceHttpGetAllHeader(
+        request: i32,
+        header: *mut *mut u8,
+        header_size: *mut u32,
+    ) -> i32;
+    pub fn sceHttpGetNetworkErrno(request: i32, err_num: *mut i32) -> i32;
+    pub fn sceHttpGetProxy(
+        id: i32,
+        activate_flag: *mut i32,
+        mode: *mut i32,
+        proxy_host: *mut u8,
+        len: usize,
+        proxy_port: *mut u16,
+    ) -> i32;
+    pub fn sceHttpInitCache(max_size: usize) -> i32;
+    pub fn sceHttpSetAuthInfoCB(id: i32, cbfunc: HttpPasswordCB) -> i32;
+    pub fn sceHttpSetProxy(
+        id: i32,
+        activate_flag: i32,
+        mode: i32,
+        new_proxy_host: *const u8,
+        new_proxy_port: u16,
+    ) -> i32;
+    pub fn sceHttpSetResHeaderMaxSize(id: i32, header_size: u32) -> i32;
+    pub fn sceHttpSetMallocFunction(
+        malloc_func: HttpMallocFunction,
+        free_func: HttpFreeFunction,
+        realloc_func: HttpReallocFunction,
+    ) -> i32;
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct in_addr(pub u32);
+
+extern "C" {
+    pub fn sceNetResolverInit() -> i32;
+    pub fn sceNetResolverCreate(
+        rid: *mut i32,
+        buf: *mut c_void,
+        buf_length: u32,
+    ) -> i32;
+    pub fn sceNetResolverDelete(rid: i32) -> i32;
+    pub fn sceNetResolverStartNtoA(
+        rid: i32,
+        hostname: *const u8,
+        addr: *mut in_addr,
+        timeout: u32,
+        retry: i32,
+    ) -> i32;
+    pub fn sceNetResolverStartAtoN(
+        rid: i32,
+        addr: *const in_addr,
+        hostname: *mut u8,
+        hostname_len: u32,
+        timeout: u32,
+        retry: i32,
+    ) -> i32;
+    pub fn sceNetResolverStop(rid: i32) -> i32;
+    pub fn sceNetResolverTerm() -> i32;
+}
diff --git a/src/psp/atrac.rs b/src/psp/atrac.rs
deleted file mode 100644
index 6df7e3d2ab..0000000000
--- a/src/psp/atrac.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-use super::c_void;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Atrac3BufferInfo {
-    pub puc_write_position_first_buf: *mut u8,
-    pub ui_writable_byte_first_buf: u32,
-    pub ui_min_write_byte_first_buf: u32,
-    pub ui_read_position_first_buf: u32,
-    pub puc_write_position_second_buf: *mut u8,
-    pub ui_writable_byte_second_buf: u32,
-    pub ui_min_write_byte_second_buf: u32,
-    pub ui_read_position_second_buf: u32,
-}
-
-extern "C" {
-    pub fn sceAtracGetAtracID(ui_codec_type: u32) -> i32;
-    pub fn sceAtracSetDataAndGetID(
-        buf: *mut c_void,
-        bufsize: usize,
-    ) -> i32;
-    pub fn sceAtracDecodeData(
-        atrac_id: i32,
-        out_samples: *mut u16,
-        out_n: *mut i32,
-        out_end: *mut i32,
-        out_remain_frame: *mut i32,
-    ) -> i32;
-    pub fn sceAtracGetRemainFrame(
-        atrac_id: i32,
-        out_remain_frame: *mut i32,
-    ) -> i32;
-    pub fn sceAtracGetStreamDataInfo(
-        atrac_id: i32,
-        write_pointer: *mut *mut u8,
-        available_bytes: *mut u32,
-        read_offset: *mut u32,
-    ) -> i32;
-    pub fn sceAtracAddStreamData(
-        atrac_id: i32,
-        bytes_to_add: u32,
-    ) -> i32;
-    pub fn sceAtracGetBitrate(
-        atrac_id: i32,
-        out_bitrate: *mut i32,
-    ) -> i32;
-    pub fn sceAtracSetLoopNum(
-        atrac_id: i32,
-        nloops: i32,
-    ) -> i32;
-    pub fn sceAtracReleaseAtracID(atrac_id: i32) -> i32;
-    pub fn sceAtracGetNextSample(
-        atrac_id: i32,
-        out_n: *mut i32,
-    ) -> i32;
-    pub fn sceAtracGetMaxSample(
-        atrac_id: i32,
-        out_max: *mut i32,
-    ) -> i32;
-    pub fn sceAtracGetBufferInfoForReseting(
-        atrac_id: i32,
-        ui_sample: u32,
-        pbuffer_info: *mut Atrac3BufferInfo,
-    ) -> i32;
-    pub fn sceAtracGetChannel(
-        atrac_id: i32,
-        pui_channel: *mut u32,
-    ) -> i32;
-    pub fn sceAtracGetInternalErrorInfo(
-        atrac_id: i32,
-        pi_result: *mut i32,
-    ) -> i32;
-    pub fn sceAtracGetLoopStatus(
-        atrac_id: i32,
-        pi_loop_num: *mut i32,
-        pui_loop_status: *mut u32,
-    ) -> i32;
-    pub fn sceAtracGetNextDecodePosition(
-        atrac_id: i32,
-        pui_sample_position: *mut u32,
-    ) -> i32;
-    pub fn sceAtracGetSecondBufferInfo(
-        atrac_id: i32,
-        pui_position: *mut u32,
-        pui_data_byte: *mut u32,
-    ) -> i32;
-    pub fn sceAtracGetSoundSample(
-        atrac_id: i32,
-        pi_end_sample: *mut i32,
-        pi_loop_start_sample: *mut i32,
-        pi_loop_end_sample: *mut i32,
-    ) -> i32;
-    pub fn sceAtracResetPlayPosition(
-        atrac_id: i32,
-        ui_sample: u32,
-        ui_write_byte_first_buf: u32,
-        ui_write_byte_second_buf: u32,
-    ) -> i32;
-    pub fn sceAtracSetData(
-        atrac_id: i32,
-        puc_buffer_addr: *mut u8,
-        ui_buffer_byte: u32,
-    ) -> i32;
-    pub fn sceAtracSetHalfwayBuffer(
-        atrac_id: i32,
-        puc_buffer_addr: *mut u8,
-        ui_read_byte: u32,
-        ui_buffer_byte: u32,
-    ) -> i32;
-    pub fn sceAtracSetHalfwayBufferAndGetID(
-        puc_buffer_addr: *mut u8,
-        ui_read_byte: u32,
-        ui_buffer_byte: u32,
-    ) -> i32;
-    pub fn sceAtracSetSecondBuffer(
-        atrac_id: i32,
-        puc_second_buffer_addr: *mut u8,
-        ui_second_buffer_byte: u32,
-    ) -> i32;
-}
diff --git a/src/psp/audio.rs b/src/psp/audio.rs
deleted file mode 100644
index 579921523c..0000000000
--- a/src/psp/audio.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use super::c_void;
-
-pub const AUDIO_VOLUME_MAX: u32 = 0x8000;
-pub const AUDIO_CHANNEL_MAX: u32 = 8;
-pub const AUDIO_NEXT_CHANNEL: i32 = -1;
-pub const AUDIO_SAMPLE_MIN: u32 = 64;
-pub const AUDIO_SAMPLE_MAX: u32 = 65472;
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum AudioFormat {
-    Stereo = 0,
-    Mono = 0x10,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct AudioInputParams {
-    pub unknown1: i32,
-    pub gain: i32,
-    pub unknown2: i32,
-    pub unknown3: i32,
-    pub unknown4: i32,
-    pub unknown5: i32,
-}
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum AudioOutputFrequency {
-    Khz48 = 48000,
-    Khz44_1 = 44100,
-    Khz32 = 32000,
-    Khz24 = 24000,
-    Khz22_05 = 22050,
-    Khz16 = 16000,
-    Khz12 = 12000,
-    Khz11_025 = 11025,
-    Khz8 = 8000,
-}
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum AudioInputFrequency {
-    Khz44_1 = 44100,
-    Khz22_05 = 22050,
-    Khz11_025 = 11025,
-}
-
-extern "C" {
-    pub fn sceAudioChReserve(
-        channel: i32,
-        sample_count: i32,
-        format: AudioFormat,
-    ) -> i32;
-    pub fn sceAudioChRelease(channel: i32) -> i32;
-    pub fn sceAudioOutput(channel: i32, vol: i32, buf: *mut c_void) -> i32;
-    pub fn sceAudioOutputBlocking(
-        channel: i32,
-        vol: i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceAudioOutputPanned(
-        channel: i32,
-        left_vol: i32,
-        right_vol: i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceAudioOutputPannedBlocking(
-        channel: i32,
-        left_vol: i32,
-        right_vol: i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceAudioGetChannelRestLen(channel: i32) -> i32;
-    pub fn sceAudioGetChannelRestLength(channel: i32) -> i32;
-    pub fn sceAudioSetChannelDataLen(channel: i32, sample_count: i32) -> i32;
-    pub fn sceAudioChangeChannelConfig(
-        channel: i32,
-        format: AudioFormat,
-    ) -> i32;
-    pub fn sceAudioChangeChannelVolume(
-        channel: i32,
-        left_vol: i32,
-        right_vol: i32,
-    ) -> i32;
-    pub fn sceAudioOutput2Reserve(sample_count: i32) -> i32;
-    pub fn sceAudioOutput2Release() -> i32;
-    pub fn sceAudioOutput2ChangeLength(sample_count: i32) -> i32;
-    pub fn sceAudioOutput2OutputBlocking(vol: i32, buf: *mut c_void) -> i32;
-    pub fn sceAudioOutput2GetRestSample() -> i32;
-    pub fn sceAudioSRCChReserve(
-        sample_count: i32,
-        freq: AudioOutputFrequency,
-        channels: i32,
-    ) -> i32;
-    pub fn sceAudioSRCChRelease() -> i32;
-    pub fn sceAudioSRCOutputBlocking(vol: i32, buf: *mut c_void) -> i32;
-    pub fn sceAudioInputInit(unknown1: i32, gain: i32, unknown2: i32) -> i32;
-    pub fn sceAudioInputInitEx(params: *mut AudioInputParams) -> i32;
-    pub fn sceAudioInputBlocking(
-        sample_count: i32,
-        freq: AudioInputFrequency,
-        buf: *mut c_void,
-    );
-    pub fn sceAudioInput(
-        sample_count: i32,
-        freq: AudioInputFrequency,
-        buf: *mut c_void,
-    );
-    pub fn sceAudioGetInputLength() -> i32;
-    pub fn sceAudioWaitInputEnd() -> i32;
-    pub fn sceAudioPollInputEnd() -> i32;
-}
diff --git a/src/psp/codec.rs b/src/psp/codec.rs
deleted file mode 100644
index 2d54f1b692..0000000000
--- a/src/psp/codec.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-extern "C" {
-    pub fn sceVideocodecOpen(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceVideocodecGetEDRAM(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceVideocodecInit(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceVideocodecDecode(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceVideocodecReleaseEDRAM(buffer: *mut u32) -> i32;
-}
-
-pub enum AudioCodec {
-    At3Plus = 0x00001000,
-    At3 = 0x00001001,
-    Mp3 = 0x00001002,
-    Aac = 0x00001003,
-}
-
-extern "C" {
-    pub fn sceAudiocodecCheckNeedMem(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceAudiocodecInit(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceAudiocodecDecode(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceAudiocodecGetEDRAM(
-        buffer: *mut u32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceAudiocodecReleaseEDRAM(buffer: *mut u32) -> i32;
-}
diff --git a/src/psp/ctrl.rs b/src/psp/ctrl.rs
deleted file mode 100644
index 045cc813af..0000000000
--- a/src/psp/ctrl.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-pub const PSP_CTRL_SELECT: i32 = 0x000001;
-pub const PSP_CTRL_START: i32 = 0x000008;
-pub const PSP_CTRL_UP: i32 = 0x000010;
-pub const PSP_CTRL_RIGHT: i32 = 0x000020;
-pub const PSP_CTRL_DOWN: i32 = 0x000040;
-pub const PSP_CTRL_LEFT: i32 = 0x000080;
-pub const PSP_CTRL_LTRIGGER: i32 = 0x000100;
-pub const PSP_CTRL_RTRIGGER: i32 = 0x000200;
-pub const PSP_CTRL_TRIANGLE: i32 = 0x001000;
-pub const PSP_CTRL_CIRCLE: i32 = 0x002000;
-pub const PSP_CTRL_CROSS: i32 = 0x004000;
-pub const PSP_CTRL_SQUARE: i32 = 0x008000;
-pub const PSP_CTRL_HOME: i32 = 0x010000;
-pub const PSP_CTRL_HOLD: i32 = 0x020000;
-pub const PSP_CTRL_NOTE: i32 = 0x800000;
-pub const PSP_CTRL_SCREEN: i32 = 0x400000;
-pub const PSP_CTRL_VOLUP: i32 = 0x100000;
-pub const PSP_CTRL_VOLDOWN: i32 = 0x200000;
-pub const PSP_CTRL_WLAN_UP: i32 = 0x040000;
-pub const PSP_CTRL_REMOTE: i32 = 0x080000;
-pub const PSP_CTRL_DISC: i32 = 0x1000000;
-pub const PSP_CTRL_MS: i32 = 0x2000000;
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum CtrlMode {
-    Digital = 0,
-    Analaog,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct SceCtrlData {
-    pub timestamp: u32,
-    pub buttons: i32,
-    pub lx: u8,
-    pub ly: u8,
-    pub rsrv: [u8; 6],
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct SceCtrlLatch {
-    pub ui_make: u32,
-    pub ui_break: u32,
-    pub ui_press: u32,
-    pub ui_release: u32,
-}
-
-extern "C" {
-    pub fn sceCtrlSetSamplingCycle(cycle: i32) -> i32;
-    pub fn sceCtrlGetSamplingCycle(pcycle: *mut i32) -> i32;
-    pub fn sceCtrlSetSamplingMode(mode: CtrlMode) -> i32;
-    pub fn sceCtrlGetSamplingMode(pmode: *mut i32) -> i32;
-    pub fn sceCtrlPeekBufferPositive(
-        pad_data: *mut SceCtrlData,
-        count: i32,
-    ) -> i32;
-    pub fn sceCtrlPeekBufferNegative(
-        pad_data: *mut SceCtrlData,
-        count: i32,
-    ) -> i32;
-    pub fn sceCtrlReadBufferPositive(
-        pad_data: *mut SceCtrlData,
-        count: i32,
-    ) -> i32;
-    pub fn sceCtrlReadBufferNegative(
-        pad_data: *mut SceCtrlData,
-        count: i32,
-    ) -> i32;
-    pub fn sceCtrlPeekLatch(latch_data: *mut SceCtrlLatch) -> i32;
-    pub fn sceCtrlReadLatch(latch_data: *mut SceCtrlLatch) -> i32;
-    pub fn sceCtrlSetIdleCancelThreshold(idlereset: i32, idleback: i32)
-        -> i32;
-    pub fn sceCtrlGetIdleCancelThreshold(
-        idlereset: *mut i32,
-        idleback: *mut i32,
-    ) -> i32;
-}
diff --git a/src/psp/display.rs b/src/psp/display.rs
deleted file mode 100644
index 2c2cd70fef..0000000000
--- a/src/psp/display.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use super::c_void;
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum DisplayMode {
-    Lcd = 0,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum DisplayPixelFormat {
-    Psm5650 = 0,
-    Psm5551 = 1,
-    Psm4444 = 2,
-    Psm8888 = 3,
-}
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum DisplaySetBufSync {
-    Immediate = 0,
-    NextFrame = 1,
-}
-
-extern "C" {
-    pub fn sceDisplaySetMode(
-        mode: DisplayMode,
-        width: usize,
-        height: usize,
-    ) -> u32;
-    pub fn sceDisplayGetMode(
-        pmode: *mut i32,
-        pwidth: *mut i32,
-        pheight: *mut i32,
-    ) -> i32;
-    pub fn sceDisplaySetFrameBuf(
-        top_addr: *const u8,
-        buffer_width: usize,
-        pixel_format: DisplayPixelFormat,
-        sync: DisplaySetBufSync,
-    ) -> u32;
-    pub fn sceDisplayGetFrameBuf(
-        top_addr: *mut *mut c_void,
-        buffer_width: *mut usize,
-        pixel_format: *mut DisplayPixelFormat,
-        sync: DisplaySetBufSync,
-    ) -> i32;
-    pub fn sceDisplayGetVcount() -> u32;
-    pub fn sceDisplayWaitVblank() -> i32;
-    pub fn sceDisplayWaitVblankCB() -> i32;
-    pub fn sceDisplayWaitVblankStart() -> i32;
-    pub fn sceDisplayWaitVblankStartCB() -> i32;
-    pub fn sceDisplayGetAccumulatedHcount() -> i32;
-    pub fn sceDisplayGetCurrentHcount() -> i32;
-    pub fn sceDisplayGetFramePerSec() -> f32;
-    pub fn sceDisplayIsForeground() -> i32;
-    pub fn sceDisplayIsVblank() -> i32;
-}
diff --git a/src/psp/ge.rs b/src/psp/ge.rs
deleted file mode 100644
index 2663565a62..0000000000
--- a/src/psp/ge.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-use super::c_void;
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct GeContext {
-    pub context: [u32; 512],
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct GeStack {
-    pub stack: [u32; 8],
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct GeCallbackData {
-    pub signal_func: Option<extern "C" fn(id: i32, arg: *mut c_void)>,
-    pub signal_arg: *mut c_void,
-    pub finish_func: Option<extern "C" fn(id: i32, arg: *mut c_void)>,
-    pub finish_arg: *mut c_void,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct GeListArgs {
-    pub size: u32,
-    pub context: *mut GeContext,
-    pub num_stacks: u32,
-    pub stacks: *mut GeStack,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct GeBreakParam {
-    pub buf: [u32; 4],
-}
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum GeMatrixType {
-    Bone0 = 0,
-    Bone1,
-    Bone2,
-    Bone3,
-    Bone4,
-    Bone5,
-    Bone6,
-    Bone7,
-    World,
-    View,
-    Projection,
-    TexGen,
-}
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum GeListState {
-    Done = 0,
-    Queued,
-    DrawingDone,
-    StallReached,
-    CancelDone,
-}
-
-#[repr(u8)]
-#[derive(Copy, Clone)]
-pub enum GeCommand {
-    Nop = 0,
-    Vaddr = 0x1,
-    Iaddr = 0x2,
-    Prim = 0x4,
-    Bezier = 0x5,
-    Spline = 0x6,
-    BoundingBox = 0x7,
-    Jump = 0x8,
-    BJump = 0x9,
-    Call = 0xa,
-    Ret = 0xb,
-    End = 0xc,
-    Signal = 0xe,
-    Finish = 0xf,
-    Base = 0x10,
-    VertexType = 0x12,
-    OffsetAddr = 0x13,
-    Origin = 0x14,
-    Region1 = 0x15,
-    Region2 = 0x16,
-    LightingEnable = 0x17,
-    LightEnable0 = 0x18,
-    LightEnable1 = 0x19,
-    LightEnable2 = 0x1a,
-    LightEnable3 = 0x1b,
-    DepthClampEnable = 0x1c,
-    CullFaceEnable = 0x1d,
-    TextureMapEnable = 0x1e,
-    FogEnable = 0x1f,
-    DitherEnable = 0x20,
-    AlphaBlendEnable = 0x21,
-    AlphaTestEnable = 0x22,
-    ZTestEnable = 0x23,
-    StencilTestEnable = 0x24,
-    AntiAliasEnable = 0x25,
-    PatchCullEnable = 0x26,
-    ColorTestEnable = 0x27,
-    LogicOpEnable = 0x28,
-    BoneMatrixNumber = 0x2a,
-    BoneMatrixData = 0x2b,
-    MorphWeight0 = 0x2c,
-    MorphWeight1 = 0x2d,
-    MorphWeight2 = 0x2e,
-    MorphWeight3 = 0x2f,
-    MorphWeight4 = 0x30,
-    MorphWeight5 = 0x31,
-    MorphWeight6 = 0x32,
-    MorphWeight7 = 0x33,
-    PatchDivision = 0x36,
-    PatchPrimitive = 0x37,
-    PatchFacing = 0x38,
-    WorldMatrixNumber = 0x3a,
-    WorldMatrixData = 0x3b,
-    ViewMatrixNumber = 0x3c,
-    ViewMatrixData = 0x3d,
-    ProjMatrixNumber = 0x3e,
-    ProjMatrixData = 0x3f,
-    TGenMatrixNumber = 0x40,
-    TGenMatrixData = 0x41,
-    ViewportXScale = 0x42,
-    ViewportYScale = 0x43,
-    ViewportZScale = 0x44,
-    ViewportXCenter = 0x45,
-    ViewportYCenter = 0x46,
-    ViewportZCenter = 0x47,
-    TexScaleU = 0x48,
-    TexScaleV = 0x49,
-    TexOffsetU = 0x4a,
-    TexOffsetV = 0x4b,
-    OffsetX = 0x4c,
-    OffsetY = 0x4d,
-    ShadeMode = 0x50,
-    ReverseNormal = 0x51,
-    MaterialUpdate = 0x53,
-    MaterialEmissive = 0x54,
-    MaterialAmbient = 0x55,
-    MaterialDiffuse = 0x56,
-    MaterialSpecular = 0x57,
-    MaterialAlpha = 0x58,
-    MaterialSpecularCoef = 0x5b,
-    AmbientColor = 0x5c,
-    AmbientAlpha = 0x5d,
-    LightMode = 0x5e,
-    LightType0 = 0x5f,
-    LightType1 = 0x60,
-    LightType2 = 0x61,
-    LightType3 = 0x62,
-    Light0X = 0x63,
-    Light0Y,
-    Light0Z,
-    Light1X,
-    Light1Y,
-    Light1Z,
-    Light2X,
-    Light2Y,
-    Light2Z,
-    Light3X,
-    Light3Y,
-    Light3Z,
-    Light0DirectionX = 0x6f,
-    Light0DirectionY,
-    Light0DirectionZ,
-    Light1DirectionX,
-    Light1DirectionY,
-    Light1DirectionZ,
-    Light2DirectionX,
-    Light2DirectionY,
-    Light2DirectionZ,
-    Light3DirectionX,
-    Light3DirectionY,
-    Light3DirectionZ,
-    Light0ConstantAtten = 0x7b,
-    Light0LinearAtten,
-    Light0QuadtraticAtten,
-    Light1ConstantAtten,
-    Light1LinearAtten,
-    Light1QuadtraticAtten,
-    Light2ConstantAtten,
-    Light2LinearAtten,
-    Light2QuadtraticAtten,
-    Light3ConstantAtten,
-    Light3LinearAtten,
-    Light3QuadtraticAtten,
-    Light0ExponentAtten = 0x87,
-    Light1ExponentAtten,
-    Light2ExponentAtten,
-    Light3ExponentAtten,
-    Light0CutoffAtten = 0x8b,
-    Light1CutoffAtten,
-    Light2CutoffAtten,
-    Light3CutoffAtten,
-    Light0Ambient = 0x8f,
-    Light0Diffuse,
-    Light0Specular,
-    Light1Ambient,
-    Light1Diffuse,
-    Light1Specular,
-    Light2Ambient,
-    Light2Diffuse,
-    Light2Specular,
-    Light3Ambient,
-    Light3Diffuse,
-    Light3Specular,
-    Cull = 0x9b,
-    FrameBufPtr = 0x9c,
-    FrameBufWidth = 0x9d,
-    ZBufPtr = 0x9e,
-    ZBufWidth = 0x9f,
-    TexAddr0 = 0xa0,
-    TexAddr1,
-    TexAddr2,
-    TexAddr3,
-    TexAddr4,
-    TexAddr5,
-    TexAddr6,
-    TexAddr7,
-    TexBufWidth0 = 0xa8,
-    TexBufWidth1,
-    TexBufWidth2,
-    TexBufWidth3,
-    TexBufWidth4,
-    TexBufWidth5,
-    TexBufWidth6,
-    TexBufWidth7,
-    ClutAddr = 0xb0,
-    ClutAddrUpper = 0xb1,
-    TransferSrc,
-    TransferSrcW,
-    TransferDst,
-    TransferDstW,
-    TexSize0 = 0xb8,
-    TexSize1,
-    TexSize2,
-    TexSize3,
-    TexSize4,
-    TexSize5,
-    TexSize6,
-    TexSize7,
-    TexMapMode = 0xc0,
-    TexShadeLs = 0xc1,
-    TexMode = 0xc2,
-    TexFormat = 0xc3,
-    LoadClut = 0xc4,
-    ClutFormat = 0xc5,
-    TexFilter = 0xc6,
-    TexWrap = 0xc7,
-    TexLevel = 0xc8,
-    TexFunc = 0xc9,
-    TexEnvColor = 0xca,
-    TexFlush = 0xcb,
-    TexSync = 0xcc,
-    Fog1 = 0xcd,
-    Fog2 = 0xce,
-    FogColor = 0xcf,
-    TexLodSlope = 0xd0,
-    FramebufPixFormat = 0xd2,
-    ClearMode = 0xd3,
-    Scissor1 = 0xd4,
-    Scissor2 = 0xd5,
-    MinZ = 0xd6,
-    MaxZ = 0xd7,
-    ColorTest = 0xd8,
-    ColorRef = 0xd9,
-    ColorTestmask = 0xda,
-    AlphaTest = 0xdb,
-    StencilTest = 0xdc,
-    StencilOp = 0xdd,
-    ZTest = 0xde,
-    BlendMode = 0xdf,
-    BlendFixedA = 0xe0,
-    BlendFixedB = 0xe1,
-    Dith0 = 0xe2,
-    Dith1,
-    Dith2,
-    Dith3,
-    LogicOp = 0xe6,
-    ZWriteDisable = 0xe7,
-    MaskRgb = 0xe8,
-    MaskAlpha = 0xe9,
-    TransferStart = 0xea,
-    TransferSrcPos = 0xeb,
-    TransferDstPos = 0xec,
-    TransferSize = 0xee,
-    Vscx = 0xf0,
-    Vscy = 0xf1,
-    Vscz = 0xf2,
-    Vtcs = 0xf3,
-    Vtct = 0xf4,
-    Vtcq = 0xf5,
-    Vcv = 0xf6,
-    Vap = 0xf7,
-    Vfc = 0xf8,
-    Vscv = 0xf9,
-
-    Unknown03 = 0x03,
-    Unknown0D = 0x0d,
-    Unknown11 = 0x11,
-    Unknown29 = 0x29,
-    Unknown34 = 0x34,
-    Unknown35 = 0x35,
-    Unknown39 = 0x39,
-    Unknown4E = 0x4e,
-    Unknown4F = 0x4f,
-    Unknown52 = 0x52,
-    Unknown59 = 0x59,
-    Unknown5A = 0x5a,
-    UnknownB6 = 0xb6,
-    UnknownB7 = 0xb7,
-    UnknownD1 = 0xd1,
-    UnknownED = 0xed,
-    UnknownEF = 0xef,
-    UnknownFA = 0xfa,
-    UnknownFB = 0xfb,
-    UnknownFC = 0xfc,
-    UnknownFD = 0xfd,
-    UnknownFE = 0xfe,
-    NopFF = 0xff,
-}
-
-extern "C" {
-    pub fn sceGeEdramGetSize() -> u32;
-    pub fn sceGeEdramGetAddr() -> *mut u8;
-    pub fn sceGeEdramSetAddrTranslation(width: i32) -> i32;
-    pub fn sceGeGetCmd(cmd: i32) -> u32;
-    pub fn sceGeGetMtx(type_: GeMatrixType, matrix: *mut c_void) -> i32;
-    pub fn sceGeGetStack(stack_id: i32, stack: *mut GeStack) -> i32;
-    pub fn sceGeSaveContext(context: *mut GeContext) -> i32;
-    pub fn sceGeRestoreContext(context: *const GeContext) -> i32;
-    pub fn sceGeListEnQueue(
-        list: *const c_void,
-        stall: *mut c_void,
-        cbid: i32,
-        arg: *mut GeListArgs,
-    ) -> i32;
-    pub fn sceGeListEnQueueHead(
-        list: *const c_void,
-        stall: *mut c_void,
-        cbid: i32,
-        arg: *mut GeListArgs,
-    ) -> i32;
-    pub fn sceGeListDeQueue(qid: i32) -> i32;
-    pub fn sceGeListUpdateStallAddr(qid: i32, stall: *mut c_void) -> i32;
-    pub fn sceGeListSync(qid: i32, sync_type: i32) -> GeListState;
-    pub fn sceGeDrawSync(sync_type: i32) -> GeListState;
-    pub fn sceGeBreak(mode: i32, p_param: *mut GeBreakParam) -> i32;
-    pub fn sceGeContinue() -> i32;
-    pub fn sceGeSetCallback(cb: *mut GeCallbackData) -> i32;
-    pub fn sceGeUnsetCallback(cbid: i32) -> i32;
-}
diff --git a/src/psp/gu.rs b/src/psp/gu.rs
deleted file mode 100644
index c64eb020a0..0000000000
--- a/src/psp/gu.rs
+++ /dev/null
@@ -1,625 +0,0 @@
-use super::{
-    c_void, DisplayPixelFormat, GeCommand, GeContext, GeListState,
-    ScePspFMatrix4, ScePspFVector3, ScePspIMatrix4,
-};
-
-pub type GuCallback = Option<extern "C" fn(id: i32, arg: *mut c_void)>;
-pub type GuSwapBuffersCallback =
-    Option<extern "C" fn(display: *mut *mut c_void, render: *mut *mut c_void)>;
-
-pub const GU_PI: f32 = 3.141593;
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum GuPrimitive {
-    Points = 0,
-    Lines = 1,
-    LineStrip = 2,
-    Triangles = 3,
-    TriangleStrip = 4,
-    TriangleFan = 5,
-    Sprites = 6,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum PatchPrimitive {
-    Points = 0,
-    LineStrip = 2,
-    TriangleStrip = 4,
-}
-
-#[derive(Clone, Copy, Eq, PartialEq)]
-#[repr(u32)]
-pub enum GuState {
-    AlphaTest = 0,
-    DepthTest = 1,
-    ScissorTest = 2,
-    StencilTest = 3,
-    Blend = 4,
-    CullFace = 5,
-    Dither = 6,
-    Fog = 7,
-    ClipPlanes = 8,
-    Texture2D = 9,
-    Lighting = 10,
-    Light0 = 11,
-    Light1 = 12,
-    Light2 = 13,
-    Light3 = 14,
-    LineSmooth = 15,
-    PatchCullFace = 16,
-    ColorTest = 17,
-    ColorLogicOp = 18,
-    FaceNormalReverse = 19,
-    PatchFace = 20,
-    Fragment2X = 21,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum MatrixMode {
-    Projection = 0,
-    View = 1,
-    Model = 2,
-    Texture = 3,
-}
-
-pub const GU_TEXTURE_8BIT: i32 = 1;
-pub const GU_TEXTURE_16BIT: i32 = 2;
-pub const GU_TEXTURE_32BITF: i32 = 3;
-pub const GU_COLOR_5650: i32 = 4 << 2;
-pub const GU_COLOR_5551: i32 = 5 << 2;
-pub const GU_COLOR_4444: i32 = 6 << 2;
-pub const GU_COLOR_8888: i32 = 7 << 2;
-pub const GU_NORMAL_8BIT: i32 = 1 << 5;
-pub const GU_NORMAL_16BIT: i32 = 2 << 5;
-pub const GU_NORMAL_32BITF: i32 = 3 << 5;
-pub const GU_VERTEX_8BIT: i32 = 1 << 7;
-pub const GU_VERTEX_16BIT: i32 = 2 << 7;
-pub const GU_VERTEX_32BITF: i32 = 3 << 7;
-pub const GU_WEIGHT_8BIT: i32 = 1 << 9;
-pub const GU_WEIGHT_16BIT: i32 = 2 << 9;
-pub const GU_WEIGHT_32BITF: i32 = 3 << 9;
-pub const GU_INDEX_8BIT: i32 = 1 << 11;
-pub const GU_INDEX_16BIT: i32 = 2 << 11;
-pub const GU_WEIGHTS1: i32 = num_weights(1);
-pub const GU_WEIGHTS2: i32 = num_weights(2);
-pub const GU_WEIGHTS3: i32 = num_weights(3);
-pub const GU_WEIGHTS4: i32 = num_weights(4);
-pub const GU_WEIGHTS5: i32 = num_weights(5);
-pub const GU_WEIGHTS6: i32 = num_weights(6);
-pub const GU_WEIGHTS7: i32 = num_weights(7);
-pub const GU_WEIGHTS8: i32 = num_weights(8);
-pub const GU_VERTICES1: i32 = num_vertices(1);
-pub const GU_VERTICES2: i32 = num_vertices(2);
-pub const GU_VERTICES3: i32 = num_vertices(3);
-pub const GU_VERTICES4: i32 = num_vertices(4);
-pub const GU_VERTICES5: i32 = num_vertices(5);
-pub const GU_VERTICES6: i32 = num_vertices(6);
-pub const GU_VERTICES7: i32 = num_vertices(7);
-pub const GU_VERTICES8: i32 = num_vertices(8);
-pub const GU_TRANSFORM_2D: i32 = 1 << 23;
-pub const GU_TRANSFORM_3D: i32 = 0;
-
-const fn num_weights(n: u32) -> i32 {
-    (((n - 1) & 7) << 14) as i32
-}
-
-const fn num_vertices(n: u32) -> i32 {
-    (((n - 1) & 7) << 18) as i32
-}
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum TexturePixelFormat {
-    Psm5650 = 0,
-    Psm5551 = 1,
-    Psm4444 = 2,
-    Psm8888 = 3,
-    PsmT4 = 4,
-    PsmT8 = 5,
-    PsmT16 = 6,
-    PsmT32 = 7,
-    PsmDxt1 = 8,
-    PsmDxt3 = 9,
-    PsmDxt5 = 10,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum SplineMode {
-    FillFill = 0,
-    OpenFill = 1,
-    FillOpen = 2,
-    OpenOpen = 3,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum ShadingModel {
-    Flat = 0,
-    Smooth = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum LogicalOperation {
-    Clear = 0,
-    And = 1,
-    AndReverse = 2,
-    Copy = 3,
-    AndInverted = 4,
-    Noop = 5,
-    Xor = 6,
-    Or = 7,
-    Nor = 8,
-    Equiv = 9,
-    Inverted = 10,
-    OrReverse = 11,
-    CopyInverted = 12,
-    OrInverted = 13,
-    Nand = 14,
-    Set = 15,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum TextureFilter {
-    Nearest = 0,
-    Linear = 1,
-    NearestMipmapNearest = 4,
-    LinearMipmapNearest = 5,
-    NearestMipmapLinear = 6,
-    LinearMipmapLinear = 7,
-}
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum TextureMapMode {
-    TextureCoords = 0,
-    TextureMatrix = 1,
-    EnvironmentMap = 2,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum TextureLevelMode {
-    Auto = 0,
-    Const = 1,
-    Slope = 2,
-}
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum TextureProjectionMapMode {
-    Position = 0,
-    Uv = 1,
-    NormalizedNormal = 2,
-    Normal = 3,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum GuTexWrapMode {
-    Repeat = 0,
-    Clamp = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum FrontFaceDirection {
-    Clockwise = 0,
-    CounterClockwise = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum AlphaFunc {
-    Never = 0,
-    Always,
-    Equal,
-    NotEqual,
-    Less,
-    LessOrEqual,
-    Greater,
-    GreaterOrEqual,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum StencilFunc {
-    Never = 0,
-    Always,
-    Equal,
-    NotEqual,
-    Less,
-    LessOrEqual,
-    Greater,
-    GreaterOrEqual,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum ColorFunc {
-    Never = 0,
-    Always,
-    Equal,
-    NotEqual,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum DepthFunc {
-    Never = 0,
-    Always,
-    Equal,
-    NotEqual,
-    Less,
-    LessOrEqual,
-    Greater,
-    GreaterOrEqual,
-}
-
-pub const GU_COLOR_BUFFER_BIT: i32 = 1;
-pub const GU_STENCIL_BUFFER_BIT: i32 = 2;
-pub const GU_DEPTH_BUFFER_BIT: i32 = 4;
-pub const GU_FAST_CLEAR_BIT: i32 = 16;
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum TextureEffect {
-    Modulate = 0,
-    Decal = 1,
-    Blend = 2,
-    Replace = 3,
-    Add = 4,
-}
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum TextureColorComponent {
-    Rgb = 0,
-    Rgba = 1,
-}
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-pub enum MipmapLevel {
-    None = 0,
-    Level1,
-    Level2,
-    Level3,
-    Level4,
-    Level5,
-    Level6,
-    Level7,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum BlendOp {
-    Add = 0,
-    Subtract = 1,
-    ReverseSubtract = 2,
-    Min = 3,
-    Max = 4,
-    Abs = 5,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum BlendSrc {
-    SrcColor = 0,
-    OneMinusSrcColor = 1,
-    SrcAlpha = 2,
-    OneMinusSrcAlpha = 3,
-    Fix = 10,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum BlendDst {
-    DstColor = 0,
-    OneMinusDstColor = 1,
-    DstAlpha = 4,
-    OneMinusDstAlpha = 5,
-    Fix = 10,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum StencilOperation {
-    Keep = 0,
-    Zero = 1,
-    Replace = 2,
-    Invert = 3,
-    Incr = 4,
-    Decr = 5,
-}
-
-pub const GU_AMBIENT: i32 = 1;
-pub const GU_DIFFUSE: i32 = 2;
-pub const GU_SPECULAR: i32 = 4;
-pub const GU_UNKNOWN_LIGHT_COMPONENT: i32 = 8;
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum LightMode {
-    SingleColor = 0,
-    SeparateSpecularColor = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum LightType {
-    Directional = 0,
-    Pointlight = 1,
-    Spotlight = 2,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum GuContextType {
-    Direct = 0,
-    Call = 1,
-    Send = 2,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum GuQueueMode {
-    Tail = 0,
-    Head = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum GuSyncMode {
-    Finish = 0,
-    Signal = 1,
-    Done = 2,
-    List = 3,
-    Send = 4,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum GuSyncBehavior {
-    Wait = 0,
-    NoWait = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum GuCallbackId {
-    Signal = 1,
-    Finish = 4,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum SignalBehavior {
-    Suspend = 1,
-    Continue = 2,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum ClutPixelFormat {
-    Psm5650 = 0,
-    Psm5551 = 1,
-    Psm4444 = 2,
-    Psm8888 = 3,
-}
-
-extern "C" {
-    pub fn sceGuDepthBuffer(zbp: *mut c_void, zbw: i32);
-    pub fn sceGuDispBuffer(
-        width: i32,
-        height: i32,
-        dispbp: *mut c_void,
-        dispbw: i32,
-    );
-    pub fn sceGuDrawBuffer(
-        psm: DisplayPixelFormat,
-        fbp: *mut c_void,
-        fbw: i32,
-    );
-    pub fn sceGuDrawBufferList(
-        psm: DisplayPixelFormat,
-        fbp: *mut c_void,
-        fbw: i32,
-    );
-    pub fn sceGuDisplay(state: bool) -> bool;
-    pub fn sceGuDepthFunc(function: DepthFunc);
-    pub fn sceGuDepthMask(mask: i32);
-
-    pub fn sceGuDepthOffset(offset: i32);
-    pub fn sceGuDepthRange(near: i32, far: i32);
-
-    pub fn sceGuFog(near: f32, far: f32, color: u32);
-    pub fn sceGuInit();
-    pub fn sceGuTerm();
-    pub fn sceGuBreak(mode: i32);
-
-    pub fn sceGuContinue();
-    pub fn sceGuSetCallback(
-        signal: GuCallbackId,
-        callback: GuCallback,
-    ) -> GuCallback;
-    pub fn sceGuSignal(behavior: SignalBehavior, signal: i32);
-    pub fn sceGuSendCommandf(cmd: GeCommand, argument: f32);
-    pub fn sceGuSendCommandi(cmd: GeCommand, argument: i32);
-    pub fn sceGuGetMemory(size: i32) -> *mut c_void;
-    pub fn sceGuStart(context_type: GuContextType, list: *mut c_void);
-    pub fn sceGuFinish() -> i32;
-    pub fn sceGuFinishId(id: u32) -> i32;
-    pub fn sceGuCallList(list: *const c_void);
-    pub fn sceGuCallMode(mode: i32);
-    pub fn sceGuCheckList() -> i32;
-    pub fn sceGuSendList(
-        mode: GuQueueMode,
-        list: *const c_void,
-        context: *mut GeContext,
-    );
-    pub fn sceGuSwapBuffers() -> *mut c_void;
-    pub fn sceGuSync(
-        mode: GuSyncMode,
-        behavior: GuSyncBehavior,
-    ) -> GeListState;
-    pub fn sceGuDrawArray(
-        prim: GuPrimitive,
-        vtype: i32,
-        count: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-    pub fn sceGuBeginObject(
-        vtype: i32,
-        count: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-    pub fn sceGuEndObject();
-    pub fn sceGuSetStatus(state: GuState, status: i32);
-    pub fn sceGuGetStatus(state: GuState) -> bool;
-    pub fn sceGuSetAllStatus(status: i32);
-    pub fn sceGuGetAllStatus() -> i32;
-    pub fn sceGuEnable(state: GuState);
-    pub fn sceGuDisable(state: GuState);
-    pub fn sceGuLight(
-        light: i32,
-        type_: LightType,
-        components: i32,
-        position: &ScePspFVector3,
-    );
-    pub fn sceGuLightAtt(light: i32, atten0: f32, atten1: f32, atten2: f32);
-    pub fn sceGuLightColor(light: i32, component: i32, color: u32);
-    pub fn sceGuLightMode(mode: LightMode);
-    pub fn sceGuLightSpot(
-        light: i32,
-        direction: &ScePspFVector3,
-        exponent: f32,
-        cutoff: f32,
-    );
-    pub fn sceGuClear(flags: i32);
-    pub fn sceGuClearColor(color: u32);
-    pub fn sceGuClearDepth(depth: u32);
-    pub fn sceGuClearStencil(stencil: u32);
-    pub fn sceGuPixelMask(mask: u32);
-    pub fn sceGuColor(color: u32);
-    pub fn sceGuColorFunc(func: ColorFunc, color: u32, mask: u32);
-    pub fn sceGuColorMaterial(components: i32);
-    pub fn sceGuAlphaFunc(func: AlphaFunc, value: i32, mask: i32);
-
-    pub fn sceGuAmbient(color: u32);
-
-    pub fn sceGuAmbientColor(color: u32);
-    pub fn sceGuBlendFunc(
-        op: BlendOp,
-        src: BlendSrc,
-        dest: BlendDst,
-        src_fix: u32,
-        dest_fix: u32,
-    );
-    pub fn sceGuMaterial(components: i32, color: u32);
-    pub fn sceGuModelColor(
-        emissive: u32,
-        ambient: u32,
-        diffuse: u32,
-        specular: u32,
-    );
-    pub fn sceGuStencilFunc(func: StencilFunc, ref_: i32, mask: i32);
-    pub fn sceGuStencilOp(
-        fail: StencilOperation,
-        zfail: StencilOperation,
-        zpass: StencilOperation,
-    );
-    pub fn sceGuSpecular(power: f32);
-    pub fn sceGuFrontFace(order: FrontFaceDirection);
-    pub fn sceGuLogicalOp(op: LogicalOperation);
-    pub fn sceGuSetDither(matrix: &ScePspIMatrix4);
-    pub fn sceGuShadeModel(mode: ShadingModel);
-    pub fn sceGuCopyImage(
-        psm: DisplayPixelFormat,
-        sx: i32,
-        sy: i32,
-        width: i32,
-        height: i32,
-        srcw: i32,
-        src: *mut c_void,
-        dx: i32,
-        dy: i32,
-        destw: i32,
-        dest: *mut c_void,
-    );
-    pub fn sceGuTexEnvColor(color: u32);
-    pub fn sceGuTexFilter(min: TextureFilter, mag: TextureFilter);
-    pub fn sceGuTexFlush();
-    pub fn sceGuTexFunc(tfx: TextureEffect, tcc: TextureColorComponent);
-    pub fn sceGuTexImage(
-        mipmap: MipmapLevel,
-        width: i32,
-        height: i32,
-        tbw: i32,
-        tbp: *const c_void,
-    );
-    pub fn sceGuTexLevelMode(mode: TextureLevelMode, bias: f32);
-    pub fn sceGuTexMapMode(mode: TextureMapMode, a1: u32, a2: u32);
-    pub fn sceGuTexMode(
-        tpsm: TexturePixelFormat,
-        maxmips: i32,
-        a2: i32,
-        swizzle: i32,
-    );
-    pub fn sceGuTexOffset(u: f32, v: f32);
-    pub fn sceGuTexProjMapMode(mode: TextureProjectionMapMode);
-    pub fn sceGuTexScale(u: f32, v: f32);
-
-    pub fn sceGuTexSlope(slope: f32);
-    pub fn sceGuTexSync();
-    pub fn sceGuTexWrap(u: GuTexWrapMode, v: GuTexWrapMode);
-    pub fn sceGuClutLoad(num_blocks: i32, cbp: *const c_void);
-    pub fn sceGuClutMode(
-        cpsm: ClutPixelFormat,
-        shift: u32,
-        mask: u32,
-        a3: u32,
-    );
-    pub fn sceGuOffset(x: u32, y: u32);
-    pub fn sceGuScissor(x: i32, y: i32, w: i32, h: i32);
-    pub fn sceGuViewport(cx: i32, cy: i32, width: i32, height: i32);
-    pub fn sceGuDrawBezier(
-        v_type: i32,
-        u_count: i32,
-        v_count: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-    pub fn sceGuPatchDivide(ulevel: u32, vlevel: u32);
-
-    pub fn sceGuPatchFrontFace(a0: u32);
-    pub fn sceGuPatchPrim(prim: PatchPrimitive);
-
-    pub fn sceGuDrawSpline(
-        v_type: i32,
-        u_count: i32,
-        v_count: i32,
-        u_edge: i32,
-        v_edge: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-    pub fn sceGuSetMatrix(type_: MatrixMode, matrix: &ScePspFMatrix4);
-    pub fn sceGuBoneMatrix(index: u32, matrix: &ScePspFMatrix4);
-    pub fn sceGuMorphWeight(index: i32, weight: f32);
-    pub fn sceGuDrawArrayN(
-        primitive_type: GuPrimitive,
-        v_type: i32,
-        count: i32,
-        a3: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-}
diff --git a/src/psp/gum.rs b/src/psp/gum.rs
deleted file mode 100644
index 044c7e092d..0000000000
--- a/src/psp/gum.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use super::{c_void, GuPrimitive, MatrixMode, ScePspFMatrix4, ScePspFVector3};
-
-extern "C" {
-    pub fn sceGumDrawArray(
-        prim: GuPrimitive,
-        v_type: i32,
-        count: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-
-    pub fn sceGumDrawArrayN(
-        prim: GuPrimitive,
-        v_type: i32,
-        count: i32,
-        a3: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-
-    pub fn sceGumDrawBezier(
-        v_type: i32,
-        u_count: i32,
-        v_count: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-
-    pub fn sceGumDrawSpline(
-        v_type: i32,
-        u_count: i32,
-        v_count: i32,
-        u_edge: i32,
-        v_edge: i32,
-        indices: *const c_void,
-        vertices: *const c_void,
-    );
-
-    pub fn sceGumFastInverse();
-    pub fn sceGumFullInverse();
-    pub fn sceGumLoadIdentity();
-    pub fn sceGumLoadMatrix(m: &ScePspFMatrix4);
-    pub fn sceGumLookAt(
-        eye: &ScePspFVector3,
-        center: &ScePspFVector3,
-        up: &ScePspFVector3,
-    );
-    pub fn sceGumMatrixMode(mode: MatrixMode);
-    pub fn sceGumMultMatrix(m: &ScePspFMatrix4);
-    pub fn sceGumOrtho(
-        left: f32,
-        right: f32,
-        bottom: f32,
-        top: f32,
-        near: f32,
-        far: f32,
-    );
-    pub fn sceGumPerspective(fovy: f32, aspect: f32, near: f32, far: f32);
-    pub fn sceGumPopMatrix();
-    pub fn sceGumPushMatrix();
-    pub fn sceGumRotateX(angle: f32);
-    pub fn sceGumRotateY(angle: f32);
-    pub fn sceGumRotateZ(angle: f32);
-    pub fn sceGumRotateXYZ(v: &ScePspFVector3);
-    pub fn sceGumRotateZYX(v: &ScePspFVector3);
-    pub fn sceGumScale(v: &ScePspFVector3);
-    pub fn sceGumStoreMatrix(m: &mut ScePspFMatrix4);
-    pub fn sceGumTranslate(v: &ScePspFVector3);
-    pub fn sceGumUpdateMatrix();
-}
diff --git a/src/psp/hprm.rs b/src/psp/hprm.rs
deleted file mode 100644
index fcd8b8ae35..0000000000
--- a/src/psp/hprm.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-pub const PLAY_PAUSE: i32 = 0x1;
-pub const FORWARD: i32 = 0x4;
-pub const BACK: i32 = 0x8;
-pub const VOL_UP: i32 = 0x10;
-pub const VOL_DOWN: i32 = 0x20;
-pub const HOLD: i32 = 0x80;
-
-extern "C" {
-    pub fn sceHprmPeekCurrentKey(key: *mut i32) -> i32;
-    pub fn sceHprmPeekLatch(latch: *mut [u32;4]) -> i32;
-    pub fn sceHprmReadLatch(latch: *mut [u32;4]) -> i32;
-    pub fn sceHprmIsHeadphoneExist() -> i32;
-    pub fn sceHprmIsRemoteExist() -> i32;
-    pub fn sceHprmIsMicrophoneExist() -> i32;
-}
diff --git a/src/psp/io.rs b/src/psp/io.rs
deleted file mode 100644
index f9acaaa47b..0000000000
--- a/src/psp/io.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-use super::{c_void, ScePspDateTime, SceUid};
-
-pub type IoPermissions = i32;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceIoDirent {
-    pub d_stat: SceIoStat,
-    pub d_name: [u8; 256usize],
-    pub d_private: *mut c_void,
-    pub dummy: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceIoStat {
-    pub st_mode: i32,
-    pub st_attr: i32,
-    pub st_size: i64,
-    pub st_ctime: ScePspDateTime,
-    pub st_atime: ScePspDateTime,
-    pub st_mtime: ScePspDateTime,
-    pub st_private: [u32; 6usize],
-}
-
-pub const FIO_S_IFLNK: i32 = 0x4000;
-pub const FIO_S_IFDIR: i32 = 0x1000;
-pub const FIO_S_IFREG: i32 = 0x2000;
-pub const FIO_S_ISUID: i32 = 0x0800;
-pub const FIO_S_ISGID: i32 = 0x0400;
-pub const FIO_S_ISVTX: i32 = 0x0200;
-pub const FIO_S_IRUSR: i32 = 0x0100;
-pub const FIO_S_IWUSR: i32 = 0x0080;
-pub const FIO_S_IXUSR: i32 = 0x0040;
-pub const FIO_S_IRGRP: i32 = 0x0020;
-pub const FIO_S_IWGRP: i32 = 0x0010;
-pub const FIO_S_IXGRP: i32 = 0x0008;
-pub const FIO_S_IROTH: i32 = 0x0004;
-pub const FIO_S_IWOTH: i32 = 0x0002;
-pub const FIO_S_IXOTH: i32 = 0x0001;
-
-pub const FIO_SO_IFLNK: i32 = 0x0008;
-pub const FIO_SO_IFDIR: i32 = 0x0010;
-pub const FIO_SO_IFREG: i32 = 0x0020;
-pub const FIO_SO_IROTH: i32 = 0x0004;
-pub const FIO_SO_IWOTH: i32 = 0x0002;
-pub const FIO_SO_IXOTH: i32 = 0x0001;
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum IoAssignPerms {
-    RdWr = 0,
-    RdOnly = 1,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum IoWhence {
-    Set = 0,
-    Cur = 1,
-    End = 2,
-}
-
-pub const PSP_O_RD_ONLY: i32 = 0x0001;
-pub const PSP_O_WR_ONLY: i32 = 0x0002;
-pub const PSP_O_RD_WR: i32 = 0x0003;
-pub const PSP_O_NBLOCK: i32 = 0x0004;
-pub const PSP_O_DIR: i32 = 0x0008;
-pub const PSP_O_APPEND: i32 = 0x0100;
-pub const PSP_O_CREAT: i32 = 0x0200;
-pub const PSP_O_TRUNC: i32 = 0x0400;
-pub const PSP_O_EXCL: i32 = 0x0800;
-pub const PSP_O_NO_WAIT: i32 = 0x8000;
-
-extern "C" {
-    pub fn sceIoOpen(
-        file: *const u8,
-        flags: i32,
-        permissions: IoPermissions,
-    ) -> SceUid;
-    pub fn sceIoOpenAsync(
-        file: *const u8,
-        flags: i32,
-        permissions: IoPermissions,
-    ) -> SceUid;
-    pub fn sceIoClose(fd: SceUid) -> i32;
-    pub fn sceIoCloseAsync(fd: SceUid) -> i32;
-    pub fn sceIoRead(fd: SceUid, data: *mut c_void, size: u32) -> i32;
-    pub fn sceIoReadAsync(fd: SceUid, data: *mut c_void, size: u32) -> i32;
-    pub fn sceIoWrite(fd: SceUid, data: *const c_void, size: usize) -> i32;
-    pub fn sceIoWriteAsync(fd: SceUid, data: *const c_void, size: u32) -> i32;
-    pub fn sceIoLseek(fd: SceUid, offset: i64, whence: IoWhence) -> i64;
-    pub fn sceIoLseekAsync(fd: SceUid, offset: i64, whence: IoWhence) -> i32;
-    pub fn sceIoLseek32(fd: SceUid, offset: i32, whence: IoWhence) -> i32;
-    pub fn sceIoLseek32Async(fd: SceUid, offset: i32, whence: IoWhence)
-        -> i32;
-    pub fn sceIoRemove(file: *const u8) -> i32;
-    pub fn sceIoMkdir(dir: *const u8, mode: IoPermissions) -> i32;
-    pub fn sceIoRmdir(path: *const u8) -> i32;
-    pub fn sceIoChdir(path: *const u8) -> i32;
-    pub fn sceIoRename(oldname: *const u8, newname: *const u8) -> i32;
-    pub fn sceIoDopen(dirname: *const u8) -> SceUid;
-    pub fn sceIoDread(fd: SceUid, dir: *mut SceIoDirent) -> i32;
-    pub fn sceIoDclose(fd: SceUid) -> i32;
-    pub fn sceIoDevctl(
-        dev: *const u8,
-        cmd: u32,
-        indata: *mut c_void,
-        inlen: i32,
-        outdata: *mut c_void,
-        outlen: i32,
-    ) -> i32;
-    pub fn sceIoAssign(
-        dev1: *const u8,
-        dev2: *const u8,
-        dev3: *const u8,
-        mode: IoAssignPerms,
-        unk1: *mut c_void,
-        unk2: i32,
-    ) -> i32;
-    pub fn sceIoUnassign(dev: *const u8) -> i32;
-    pub fn sceIoGetstat(file: *const u8, stat: *mut SceIoStat) -> i32;
-    pub fn sceIoChstat(
-        file: *const u8,
-        stat: *mut SceIoStat,
-        bits: i32,
-    ) -> i32;
-    pub fn sceIoIoctl(
-        fd: SceUid,
-        cmd: u32,
-        indata: *mut c_void,
-        inlen: i32,
-        outdata: *mut c_void,
-        outlen: i32,
-    ) -> i32;
-    pub fn sceIoIoctlAsync(
-        fd: SceUid,
-        cmd: u32,
-        indata: *mut c_void,
-        inlen: i32,
-        outdata: *mut c_void,
-        outlen: i32,
-    ) -> i32;
-    pub fn sceIoSync(device: *const u8, unk: u32) -> i32;
-    pub fn sceIoWaitAsync(fd: SceUid, res: *mut i64) -> i32;
-    pub fn sceIoWaitAsyncCB(fd: SceUid, res: *mut i64) -> i32;
-    pub fn sceIoPollAsync(fd: SceUid, res: *mut i64) -> i32;
-    pub fn sceIoGetAsyncStat(fd: SceUid, poll: i32, res: *mut i64) -> i32;
-    pub fn sceIoCancel(fd: SceUid) -> i32;
-    pub fn sceIoGetDevType(fd: SceUid) -> i32;
-    pub fn sceIoChangeAsyncPriority(fd: SceUid, pri: i32) -> i32;
-    pub fn sceIoSetAsyncCallback(
-        fd: SceUid,
-        cb: SceUid,
-        argp: *mut c_void,
-    ) -> i32;
-}
diff --git a/src/psp/jpeg.rs b/src/psp/jpeg.rs
deleted file mode 100644
index a3ed6fe0eb..0000000000
--- a/src/psp/jpeg.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use super::c_void;
-extern "C" {
-    pub fn sceJpegInitMJpeg() -> i32;
-    pub fn sceJpegFinishMJpeg() -> i32;
-    pub fn sceJpegCreateMJpeg(width: i32, height: i32) -> i32;
-    pub fn sceJpegDeleteMJpeg() -> i32;
-    pub fn sceJpegDecodeMJpeg(
-        jpeg_buf: *mut u8,
-        size: usize,
-        rgba: *mut c_void,
-        unk: u32,
-    ) -> i32;
-}
diff --git a/src/psp/kernel/mod.rs b/src/psp/kernel/mod.rs
deleted file mode 100644
index 0209c5e97e..0000000000
--- a/src/psp/kernel/mod.rs
+++ /dev/null
@@ -1,376 +0,0 @@
-use super::c_void;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelLoadExecParam {
-    pub size: usize,
-    pub args: usize,
-    pub argp: *mut c_void,
-    pub key: *const u8,
-}
-
-extern "C" {
-    pub fn sceKernelExitGame();
-    pub fn sceKernelRegisterExitCallback(id: SceUid) -> i32;
-    pub fn sceKernelLoadExec(
-        file: *const u8,
-        param: *mut SceKernelLoadExecParam,
-    ) -> i32;
-}
-
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct SceUid(pub i32);
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum SceSysMemPartitionId {
-    SceKernelUnknownPartition = 0,
-    SceKernelPrimaryKernelPartition = 1,
-    SceKernelPrimaryUserPartition = 2,
-    SceKernelOtherKernelPartition1 = 3,
-    SceKernelOtherKernelPartition2 = 4,
-    SceKernelVshellPARTITION = 5,
-    SceKernelScUserPartition = 6,
-    SceKernelMeUserPartition = 7,
-    SceKernelExtendedScKernelPartition = 8,
-    SceKernelExtendedSc2KernelPartition = 9,
-    SceKernelExtendedMeKernelPartition = 10,
-    SceKernelVshellKernelPartition = 11,
-    SceKernelExtendedKernelPartition = 12,
-}
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum SceSysMemBlockTypes {
-    Low = 0,
-    High,
-    Addr,
-}
-
-extern "C" {
-    pub fn sceKernelAllocPartitionMemory(
-        partition: SceSysMemPartitionId,
-        name: *const u8,
-        type_: SceSysMemBlockTypes,
-        size: u32,
-        addr: *mut c_void,
-    ) -> SceUid;
-    pub fn sceKernelGetBlockHeadAddr(blockid: SceUid) -> *mut c_void;
-    pub fn sceKernelFreePartitionMemory(blockid: SceUid) -> i32;
-    pub fn sceKernelTotalFreeMemSize() -> usize;
-    pub fn sceKernelMaxFreeMemSize() -> usize;
-    pub fn sceKernelDevkitVersion() -> u32;
-    pub fn sceKernelSetCompiledSdkVersion(version: u32) -> i32;
-    pub fn sceKernelGetCompiledSdkVersion() -> u32;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct timeval {
-    pub tv_sec: i32,
-    pub tv_usec: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct timezone {
-    pub tz_minutes_west: i32,
-    pub tz_dst_time: i32,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelUtilsSha1Context {
-    pub h: [u32; 5usize],
-    pub us_remains: u16,
-    pub us_computed: u16,
-    pub ull_total_len: u64,
-    pub buf: [u8; 64usize],
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelUtilsMt19937Context {
-    pub count: u32,
-    pub state: [u32; 624usize],
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelUtilsMd5Context {
-    pub h: [u32; 4usize],
-    pub pad: u32,
-    pub us_remains: u16,
-    pub us_computed: u16,
-    pub ull_total_len: u64,
-    pub buf: [u8; 64usize],
-}
-
-extern "C" {
-    pub fn sceKernelLibcTime(t: *mut i32) -> i32;
-    pub fn sceKernelLibcClock() -> u32;
-    pub fn sceKernelLibcGettimeofday(
-        tp: *mut timeval,
-        tzp: *mut timezone,
-    ) -> i32;
-    pub fn sceKernelDcacheWritebackAll();
-    pub fn sceKernelDcacheWritebackInvalidateAll();
-    pub fn sceKernelDcacheWritebackRange(p: *const c_void, size: u32);
-    pub fn sceKernelDcacheWritebackInvalidateRange(
-        p: *const c_void,
-        size: u32,
-    );
-    pub fn sceKernelDcacheInvalidateRange(p: *const c_void, size: u32);
-    pub fn sceKernelIcacheInvalidateAll();
-    pub fn sceKernelIcacheInvalidateRange(p: *const c_void, size: u32);
-    pub fn sceKernelUtilsMt19937Init(
-        ctx: *mut SceKernelUtilsMt19937Context,
-        seed: u32,
-    ) -> i32;
-    pub fn sceKernelUtilsMt19937UInt(
-        ctx: *mut SceKernelUtilsMt19937Context,
-    ) -> u32;
-    pub fn sceKernelUtilsMd5Digest(
-        data: *mut u8,
-        size: u32,
-        digest: *mut u8,
-    ) -> i32;
-    pub fn sceKernelUtilsMd5BlockInit(
-        ctx: *mut SceKernelUtilsMd5Context,
-    ) -> i32;
-    pub fn sceKernelUtilsMd5BlockUpdate(
-        ctx: *mut SceKernelUtilsMd5Context,
-        data: *mut u8,
-        size: u32,
-    ) -> i32;
-    pub fn sceKernelUtilsMd5BlockResult(
-        ctx: *mut SceKernelUtilsMd5Context,
-        digest: *mut u8,
-    ) -> i32;
-    pub fn sceKernelUtilsSha1Digest(
-        data: *mut u8,
-        size: u32,
-        digest: *mut u8,
-    ) -> i32;
-    pub fn sceKernelUtilsSha1BlockInit(
-        ctx: *mut SceKernelUtilsSha1Context,
-    ) -> i32;
-    pub fn sceKernelUtilsSha1BlockUpdate(
-        ctx: *mut SceKernelUtilsSha1Context,
-        data: *mut u8,
-        size: u32,
-    ) -> i32;
-    pub fn sceKernelUtilsSha1BlockResult(
-        ctx: *mut SceKernelUtilsSha1Context,
-        digest: *mut u8,
-    ) -> i32;
-}
-
-#[derive(Copy, Clone)]
-#[repr(packed, C)]
-pub struct IntrHandlerOptionParam {
-    size: i32,
-    entry: u32,
-    common: u32,
-    gp: u32,
-    intr_code: u16,
-    sub_count: u16,
-    intr_level: u16,
-    enabled: u16,
-    calls: u32,
-    field_1c: u32,
-    total_clock_lo: u32,
-    total_clock_hi: u32,
-    min_clock_lo: u32,
-    min_clock_hi: u32,
-    max_clock_lo: u32,
-    max_clock_hi: u32,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum Interrupt {
-    Gpio = 4,
-    Ata = 5,
-    Umd = 6,
-    Mscm0 = 7,
-    Wlan = 8,
-    Audio = 10,
-    I2c = 12,
-    Sircs = 14,
-    Systimer0 = 15,
-    Systimer1 = 16,
-    Systimer2 = 17,
-    Systimer3 = 18,
-    Thread0 = 19,
-    Nand = 20,
-    Dmacplus = 21,
-    Dma0 = 22,
-    Dma1 = 23,
-    Memlmd = 24,
-    Ge = 25,
-    Vblank = 30,
-    Mecodec = 31,
-    Hpremote = 36,
-    Mscm1 = 60,
-    Mscm2 = 61,
-    Thread1 = 65,
-    Interrupt = 66,
-}
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum SubInterrupt {
-    Gpio = Interrupt::Gpio as u32,
-    Ata = Interrupt::Ata as u32,
-    Umd = Interrupt::Umd as u32,
-    Dmacplus = Interrupt::Dmacplus as u32,
-    Ge = Interrupt::Ge as u32,
-    Display = Interrupt::Vblank as u32,
-}
-
-extern "C" {
-    pub fn sceKernelRegisterSubIntrHandler(
-        int_no: i32,
-        no: i32,
-        handler: *mut c_void,
-        arg: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelReleaseSubIntrHandler(int_no: i32, no: i32) -> i32;
-    pub fn sceKernelEnableSubIntr(int_no: i32, no: i32) -> i32;
-    pub fn sceKernelDisableSubIntr(int_no: i32, no: i32) -> i32;
-    pub fn QueryIntrHandlerInfo(
-        intr_code: SceUid,
-        sub_intr_code: SceUid,
-        data: *mut IntrHandlerOptionParam,
-    ) -> i32;
-}
-
-extern "C" {
-    pub fn sceKernelCpuSuspendIntr() -> u32;
-    pub fn sceKernelCpuResumeIntr(flags: u32);
-    pub fn sceKernelCpuResumeIntrWithSync(flags: u32);
-    pub fn sceKernelIsCpuIntrSuspended(flags: u32) -> i32;
-    pub fn sceKernelIsCpuIntrEnable() -> i32;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelLMOption {
-    pub size: usize,
-    pub m_pid_text: SceUid,
-    pub m_pid_data: SceUid,
-    pub flags: u32,
-    pub position: u8,
-    pub access: u8,
-    pub c_reserved: [u8; 2usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelSMOption {
-    pub size: usize,
-    pub m_pid_stack: SceUid,
-    pub stack_size: usize,
-    pub priority: i32,
-    pub attribute: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelModuleInfo {
-    pub size: usize,
-    pub n_segment: u8,
-    pub reserved: [u8; 3usize],
-    pub segment_addr: [i32; 4usize],
-    pub segment_size: [i32; 4usize],
-    pub entry_addr: u32,
-    pub gp_value: u32,
-    pub text_addr: u32,
-    pub text_size: u32,
-    pub data_size: u32,
-    pub bss_size: u32,
-    pub attribute: u16,
-    pub version: [u8; 2usize],
-    pub name: [u8; 28usize],
-}
-
-extern "C" {
-    pub fn sceKernelLoadModule(
-        path: *const u8,
-        flags: i32,
-        option: *mut SceKernelLMOption,
-    ) -> SceUid;
-    pub fn sceKernelLoadModuleMs(
-        path: *const u8,
-        flags: i32,
-        option: *mut SceKernelLMOption,
-    ) -> SceUid;
-    pub fn sceKernelLoadModuleByID(
-        fid: SceUid,
-        flags: i32,
-        option: *mut SceKernelLMOption,
-    ) -> SceUid;
-    pub fn sceKernelLoadModuleBufferUsbWlan(
-        buf_size: usize,
-        buf: *mut c_void,
-        flags: i32,
-        option: *mut SceKernelLMOption,
-    ) -> SceUid;
-    pub fn sceKernelStartModule(
-        mod_id: SceUid,
-        arg_size: usize,
-        argp: *mut c_void,
-        status: *mut i32,
-        option: *mut SceKernelSMOption,
-    ) -> i32;
-    pub fn sceKernelStopModule(
-        mod_id: SceUid,
-        arg_size: usize,
-        argp: *mut c_void,
-        status: *mut i32,
-        option: *mut SceKernelSMOption,
-    ) -> i32;
-    pub fn sceKernelUnloadModule(mod_id: SceUid) -> i32;
-    pub fn sceKernelSelfStopUnloadModule(
-        unknown: i32,
-        arg_size: usize,
-        argp: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelStopUnloadSelfModule(
-        arg_size: usize,
-        argp: *mut c_void,
-        status: *mut i32,
-        option: *mut SceKernelSMOption,
-    ) -> i32;
-    pub fn sceKernelQueryModuleInfo(
-        mod_id: SceUid,
-        info: *mut SceKernelModuleInfo,
-    ) -> i32;
-    pub fn sceKernelGetModuleIdList(
-        read_buf: *mut SceUid,
-        read_buf_size: i32,
-        id_count: *mut i32,
-    ) -> i32;
-}
-
-extern "C" {
-    pub fn sceKernelVolatileMemLock(
-        unk: i32,
-        ptr: *mut *mut c_void,
-        size: *mut i32,
-    ) -> i32;
-    pub fn sceKernelVolatileMemTryLock(
-        unk: i32,
-        ptr: *mut *mut c_void,
-        size: *mut i32,
-    ) -> i32;
-    pub fn sceKernelVolatileMemUnlock(unk: i32) -> i32;
-}
-
-extern "C" {
-    pub fn sceKernelStdin() -> SceUid;
-    pub fn sceKernelStdout() -> SceUid;
-    pub fn sceKernelStderr() -> SceUid;
-}
-
-mod thread;
-pub use self::thread::*;
diff --git a/src/psp/kernel/thread.rs b/src/psp/kernel/thread.rs
deleted file mode 100644
index 6b2c1a179c..0000000000
--- a/src/psp/kernel/thread.rs
+++ /dev/null
@@ -1,664 +0,0 @@
-use super::{c_void, SceUid};
-
-pub type SceKernelVTimerHandler = unsafe extern "C" fn(
-    uid: SceUid,
-    arg1: *mut SceKernelSysClock,
-    arg2: *mut SceKernelSysClock,
-    arg3: *mut c_void,
-) -> u32;
-
-pub type SceKernelVTimerHandlerWide = unsafe extern "C" fn(
-    uid: SceUid,
-    arg1: i64,
-    arg2: i64,
-    arg3: *mut c_void,
-) -> u32;
-
-pub type SceKernelThreadEventHandler =
-    unsafe extern "C" fn(mask: i32, thid: SceUid, common: *mut c_void) -> i32;
-
-pub type SceKernelAlarmHandler =
-    unsafe extern "C" fn(common: *mut c_void) -> u32;
-
-pub type SceKernelCallbackFunction =
-    unsafe extern "C" fn(arg1: i32, arg2: i32, arg: *mut c_void) -> i32;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct DebugProfilerRegs {
-    pub enable: u32,
-    pub systemck: u32,
-    pub cpuck: u32,
-    pub internal: u32,
-    pub memory: u32,
-    pub copz: u32,
-    pub vfpu: u32,
-    pub sleep: u32,
-    pub bus_access: u32,
-    pub uncached_load: u32,
-    pub uncached_store: u32,
-    pub cached_load: u32,
-    pub cached_store: u32,
-    pub i_miss: u32,
-    pub d_miss: u32,
-    pub d_writeback: u32,
-    pub cop0_inst: u32,
-    pub fpu_inst: u32,
-    pub vfpu_inst: u32,
-    pub local_bus: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelSysClock {
-    pub low: u32,
-    pub hi: u32,
-}
-
-pub type SceKernelThreadEntry =
-    unsafe extern "C" fn(args: usize, argp: *mut c_void) -> i32;
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelThreadOptParam {
-    pub size: usize,
-    pub stack_mpid: SceUid,
-}
-
-pub const THREAD_ATTR_VFPU: i32 = 0x00004000;
-pub const THREAD_ATTR_USER: i32 = 0x80000000;
-pub const THREAD_ATTR_USBWLAN: i32 = 0xa0000000;
-pub const THREAD_ATTR_VSH: i32 = 0xc0000000;
-pub const THREAD_ATTR_SCRATCH_SRAM: i32 = 0x00008000;
-pub const THREAD_ATTR_NO_FILLSTACK: i32 = 0x00100000;
-pub const THREAD_ATTR_CLEAR_STACK: i32 = 0x00200000;
-
-pub const EVENT_WAIT_MULTIPLE: i32 = 0x200;
-
-pub const EVENT_WAIT_AND: i32 = 0;
-pub const EVENT_WAIT_OR: i32 = 1;
-pub const EVENT_WAIT_CLEAR: i32 = 0x20;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelThreadInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub attr: u32,
-    pub status: i32,
-    pub entry: SceKernelThreadEntry,
-    pub stack: *mut c_void,
-    pub stack_size: i32,
-    pub gp_reg: *mut c_void,
-    pub init_priority: i32,
-    pub current_priority: i32,
-    pub wait_type: i32,
-    pub wait_id: SceUid,
-    pub wakeup_count: i32,
-    pub exit_status: i32,
-    pub run_clocks: SceKernelSysClock,
-    pub intr_preempt_count: u32,
-    pub thread_preempt_count: u32,
-    pub release_count: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelThreadRunStatus {
-    pub size: usize,
-    pub status: i32,
-    pub current_priority: i32,
-    pub wait_type: i32,
-    pub wait_id: i32,
-    pub wakeup_count: i32,
-    pub run_clocks: SceKernelSysClock,
-    pub intr_preempt_count: u32,
-    pub thread_preempt_count: u32,
-    pub release_count: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelSemaOptParam {
-    pub size: usize,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelSemaInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub attr: u32,
-    pub init_count: i32,
-    pub current_count: i32,
-    pub max_count: i32,
-    pub num_wait_threads: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelEventFlagInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub attr: u32,
-    pub init_pattern: u32,
-    pub current_pattern: u32,
-    pub num_wait_threads: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelEventFlagOptParam {
-    pub size: usize,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelMbxOptParam {
-    pub size: usize,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelMbxInfo {
-    pub size: usize,
-    pub name: [u8; 32usize],
-    pub attr: u32,
-    pub num_wait_threads: i32,
-    pub num_messages: i32,
-    pub first_message: *mut c_void,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelVTimerInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub active: i32,
-    pub base: SceKernelSysClock,
-    pub current: SceKernelSysClock,
-    pub schedule: SceKernelSysClock,
-    pub handler: SceKernelVTimerHandler,
-    pub common: *mut c_void,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelThreadEventHandlerInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub thread_id: SceUid,
-    pub mask: i32,
-    pub handler: SceKernelThreadEventHandler,
-    pub common: *mut c_void,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelAlarmInfo {
-    pub size: usize,
-    pub schedule: SceKernelSysClock,
-    pub handler: SceKernelAlarmHandler,
-    pub common: *mut c_void,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum SceKernelIdListType {
-    Thread = 1,
-    Semaphore = 2,
-    EventFlag = 3,
-    Mbox = 4,
-    Vpl = 5,
-    Fpl = 6,
-    Mpipe = 7,
-    Callback = 8,
-    ThreadEventHandler = 9,
-    Alarm = 10,
-    VTimer = 11,
-    SleepThread = 64,
-    DelayThread = 65,
-    SuspendThread = 66,
-    DormantThread = 67,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelSystemStatus {
-    pub size: usize,
-    pub status: u32,
-    pub idle_clocks: SceKernelSysClock,
-    pub comes_out_of_idle_count: u32,
-    pub thread_switch_count: u32,
-    pub vfpu_switch_count: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelMppInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub attr: u32,
-    pub buf_size: i32,
-    pub free_size: i32,
-    pub num_send_wait_threads: i32,
-    pub num_receive_wait_threads: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelVplOptParam {
-    pub size: usize,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelVplInfo {
-    pub size: usize,
-    pub name: [u8; 32],
-    pub attr: u32,
-    pub pool_size: i32,
-    pub free_size: i32,
-    pub num_wait_threads: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelFplOptParam {
-    pub size: usize,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelFplInfo {
-    pub size: usize,
-    pub name: [u8; 32usize],
-    pub attr: u32,
-    pub block_size: i32,
-    pub num_blocks: i32,
-    pub free_blocks: i32,
-    pub num_wait_threads: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelVTimerOptParam {
-    pub size: usize,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceKernelCallbackInfo {
-    pub size: usize,
-    pub name: [u8; 32usize],
-    pub thread_id: SceUid,
-    pub callback: SceKernelCallbackFunction,
-    pub common: *mut c_void,
-    pub notify_count: i32,
-    pub notify_arg: i32,
-}
-
-extern "C" {
-    pub fn sceKernelGetThreadmanIdType(uid: SceUid) -> SceKernelIdListType;
-    pub fn sceKernelCreateThread(
-        name: *const u8,
-        entry: SceKernelThreadEntry,
-        init_priority: i32,
-        stack_size: i32,
-        attr: i32,
-        option: *mut SceKernelThreadOptParam,
-    ) -> SceUid;
-    pub fn sceKernelDeleteThread(thid: SceUid) -> i32;
-    pub fn sceKernelStartThread(
-        id: SceUid,
-        arg_len: usize,
-        arg_p: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelExitThread(status: i32) -> i32;
-    pub fn sceKernelExitDeleteThread(status: i32) -> i32;
-    pub fn sceKernelTerminateThread(thid: SceUid) -> i32;
-    pub fn sceKernelTerminateDeleteThread(thid: SceUid) -> i32;
-    pub fn sceKernelSuspendDispatchThread() -> i32;
-    pub fn sceKernelResumeDispatchThread(state: i32) -> i32;
-    pub fn sceKernelSleepThread() -> i32;
-    pub fn sceKernelSleepThreadCB() -> i32;
-    pub fn sceKernelWakeupThread(thid: SceUid) -> i32;
-    pub fn sceKernelCancelWakeupThread(thid: SceUid) -> i32;
-    pub fn sceKernelSuspendThread(thid: SceUid) -> i32;
-    pub fn sceKernelResumeThread(thid: SceUid) -> i32;
-    pub fn sceKernelWaitThreadEnd(thid: SceUid, timeout: *mut u32) -> i32;
-    pub fn sceKernelWaitThreadEndCB(thid: SceUid, timeout: *mut u32) -> i32;
-    pub fn sceKernelDelayThread(delay: u32) -> i32;
-    pub fn sceKernelDelayThreadCB(delay: u32) -> i32;
-    pub fn sceKernelDelaySysClockThread(delay: *mut SceKernelSysClock) -> i32;
-    pub fn sceKernelDelaySysClockThreadCB(
-        delay: *mut SceKernelSysClock,
-    ) -> i32;
-    pub fn sceKernelChangeCurrentThreadAttr(unknown: i32, attr: i32) -> i32;
-    pub fn sceKernelChangeThreadPriority(thid: SceUid, priority: i32) -> i32;
-    pub fn sceKernelRotateThreadReadyQueue(priority: i32) -> i32;
-    pub fn sceKernelReleaseWaitThread(thid: SceUid) -> i32;
-    pub fn sceKernelGetThreadId() -> i32;
-    pub fn sceKernelGetThreadCurrentPriority() -> i32;
-    pub fn sceKernelGetThreadExitStatus(thid: SceUid) -> i32;
-    pub fn sceKernelCheckThreadStack() -> i32;
-    pub fn sceKernelGetThreadStackFreeSize(thid: SceUid) -> i32;
-    pub fn sceKernelReferThreadStatus(
-        thid: SceUid,
-        info: *mut SceKernelThreadInfo,
-    ) -> i32;
-    pub fn sceKernelReferThreadRunStatus(
-        thid: SceUid,
-        status: *mut SceKernelThreadRunStatus,
-    ) -> i32;
-    pub fn sceKernelCreateSema(
-        name: *const u8,
-        attr: u32,
-        init_val: i32,
-        max_val: i32,
-        option: *mut SceKernelSemaOptParam,
-    ) -> SceUid;
-    pub fn sceKernelDeleteSema(sema_id: SceUid) -> i32;
-    pub fn sceKernelSignalSema(sema_id: SceUid, signal: i32) -> i32;
-    pub fn sceKernelWaitSema(
-        sema_id: SceUid,
-        signal: i32,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelWaitSemaCB(
-        sema_id: SceUid,
-        signal: i32,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelPollSema(sema_id: SceUid, signal: i32) -> i32;
-    pub fn sceKernelReferSemaStatus(
-        sema_id: SceUid,
-        info: *mut SceKernelSemaInfo,
-    ) -> i32;
-    pub fn sceKernelCreateEventFlag(
-        name: *const u8,
-        attr: i32,
-        bits: i32,
-        opt: *mut SceKernelEventFlagOptParam,
-    ) -> SceUid;
-    pub fn sceKernelSetEventFlag(ev_id: SceUid, bits: u32) -> i32;
-    pub fn sceKernelClearEventFlag(ev_id: SceUid, bits: u32) -> i32;
-    pub fn sceKernelPollEventFlag(
-        ev_id: SceUid,
-        bits: u32,
-        wait: i32,
-        out_bits: *mut u32,
-    ) -> i32;
-    pub fn sceKernelWaitEventFlag(
-        ev_id: SceUid,
-        bits: u32,
-        wait: i32,
-        out_bits: *mut u32,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelWaitEventFlagCB(
-        ev_id: SceUid,
-        bits: u32,
-        wait: i32,
-        out_bits: *mut u32,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelDeleteEventFlag(ev_id: SceUid) -> i32;
-    pub fn sceKernelReferEventFlagStatus(
-        event: SceUid,
-        status: *mut SceKernelEventFlagInfo,
-    ) -> i32;
-    pub fn sceKernelCreateMbx(
-        name: *const u8,
-        attr: u32,
-        option: *mut SceKernelMbxOptParam,
-    ) -> SceUid;
-    pub fn sceKernelDeleteMbx(mbx_id: SceUid) -> i32;
-    pub fn sceKernelSendMbx(mbx_id: SceUid, message: *mut c_void) -> i32;
-    pub fn sceKernelReceiveMbx(
-        mbx_id: SceUid,
-        message: *mut *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelReceiveMbxCB(
-        mbx_id: SceUid,
-        message: *mut *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelPollMbx(mbx_id: SceUid, pmessage: *mut *mut c_void)
-        -> i32;
-    pub fn sceKernelCancelReceiveMbx(mbx_id: SceUid, num: *mut i32) -> i32;
-    pub fn sceKernelReferMbxStatus(
-        mbx_id: SceUid,
-        info: *mut SceKernelMbxInfo,
-    ) -> i32;
-    pub fn sceKernelSetAlarm(
-        clock: u32,
-        handler: SceKernelAlarmHandler,
-        common: *mut c_void,
-    ) -> SceUid;
-    pub fn sceKernelSetSysClockAlarm(
-        clock: *mut SceKernelSysClock,
-        handler: *mut SceKernelAlarmHandler,
-        common: *mut c_void,
-    ) -> SceUid;
-    pub fn sceKernelCancelAlarm(alarm_id: SceUid) -> i32;
-    pub fn sceKernelReferAlarmStatus(
-        alarm_id: SceUid,
-        info: *mut SceKernelAlarmInfo,
-    ) -> i32;
-    pub fn sceKernelCreateCallback(
-        name: *const u8,
-        func: SceKernelCallbackFunction,
-        arg: *mut c_void,
-    ) -> SceUid;
-    pub fn sceKernelReferCallbackStatus(
-        cb: SceUid,
-        status: *mut SceKernelCallbackInfo,
-    ) -> i32;
-    pub fn sceKernelDeleteCallback(cb: SceUid) -> i32;
-    pub fn sceKernelNotifyCallback(cb: SceUid, arg2: i32) -> i32;
-    pub fn sceKernelCancelCallback(cb: SceUid) -> i32;
-    pub fn sceKernelGetCallbackCount(cb: SceUid) -> i32;
-    pub fn sceKernelCheckCallback() -> i32;
-    pub fn sceKernelGetThreadmanIdList(
-        type_: SceKernelIdListType,
-        read_buf: *mut SceUid,
-        read_buf_size: i32,
-        id_count: *mut i32,
-    ) -> i32;
-    pub fn sceKernelReferSystemStatus(
-        status: *mut SceKernelSystemStatus,
-    ) -> i32;
-    pub fn sceKernelCreateMsgPipe(
-        name: *const u8,
-        part: i32,
-        attr: i32,
-        unk1: *mut c_void,
-        opt: *mut c_void,
-    ) -> SceUid;
-    pub fn sceKernelDeleteMsgPipe(uid: SceUid) -> i32;
-    pub fn sceKernelSendMsgPipe(
-        uid: SceUid,
-        message: *mut c_void,
-        size: u32,
-        unk1: i32,
-        unk2: *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelSendMsgPipeCB(
-        uid: SceUid,
-        message: *mut c_void,
-        size: u32,
-        unk1: i32,
-        unk2: *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelTrySendMsgPipe(
-        uid: SceUid,
-        message: *mut c_void,
-        size: u32,
-        unk1: i32,
-        unk2: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelReceiveMsgPipe(
-        uid: SceUid,
-        message: *mut c_void,
-        size: u32,
-        unk1: i32,
-        unk2: *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelReceiveMsgPipeCB(
-        uid: SceUid,
-        message: *mut c_void,
-        size: u32,
-        unk1: i32,
-        unk2: *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelTryReceiveMsgPipe(
-        uid: SceUid,
-        message: *mut c_void,
-        size: u32,
-        unk1: i32,
-        unk2: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelCancelMsgPipe(
-        uid: SceUid,
-        send: *mut i32,
-        recv: *mut i32,
-    ) -> i32;
-    pub fn sceKernelReferMsgPipeStatus(
-        uid: SceUid,
-        info: *mut SceKernelMppInfo,
-    ) -> i32;
-    pub fn sceKernelCreateVpl(
-        name: *const u8,
-        part: i32,
-        attr: i32,
-        size: u32,
-        opt: *mut SceKernelVplOptParam,
-    ) -> SceUid;
-    pub fn sceKernelDeleteVpl(uid: SceUid) -> i32;
-    pub fn sceKernelAllocateVpl(
-        uid: SceUid,
-        size: u32,
-        data: *mut *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelAllocateVplCB(
-        uid: SceUid,
-        size: u32,
-        data: *mut *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelTryAllocateVpl(
-        uid: SceUid,
-        size: u32,
-        data: *mut *mut c_void,
-    ) -> i32;
-    pub fn sceKernelFreeVpl(uid: SceUid, data: *mut c_void) -> i32;
-    pub fn sceKernelCancelVpl(uid: SceUid, num: *mut i32) -> i32;
-    pub fn sceKernelReferVplStatus(
-        uid: SceUid,
-        info: *mut SceKernelVplInfo,
-    ) -> i32;
-    pub fn sceKernelCreateFpl(
-        name: *const u8,
-        part: i32,
-        attr: i32,
-        size: u32,
-        blocks: u32,
-        opt: *mut SceKernelFplOptParam,
-    ) -> i32;
-    pub fn sceKernelDeleteFpl(uid: SceUid) -> i32;
-    pub fn sceKernelAllocateFpl(
-        uid: SceUid,
-        data: *mut *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelAllocateFplCB(
-        uid: SceUid,
-        data: *mut *mut c_void,
-        timeout: *mut u32,
-    ) -> i32;
-    pub fn sceKernelTryAllocateFpl(uid: SceUid, data: *mut *mut c_void)
-        -> i32;
-    pub fn sceKernelFreeFpl(uid: SceUid, data: *mut c_void) -> i32;
-    pub fn sceKernelCancelFpl(uid: SceUid, pnum: *mut i32) -> i32;
-    pub fn sceKernelReferFplStatus(
-        uid: SceUid,
-        info: *mut SceKernelFplInfo,
-    ) -> i32;
-    pub fn sceKernelUSec2SysClock(
-        usec: u32,
-        clock: *mut SceKernelSysClock,
-    ) -> i32;
-    pub fn sceKernelUSec2SysClockWide(usec: u32) -> i64;
-    pub fn sceKernelSysClock2USec(
-        clock: *mut SceKernelSysClock,
-        low: *mut u32,
-        high: *mut u32,
-    ) -> i32;
-    pub fn sceKernelSysClock2USecWide(
-        clock: i64,
-        low: *mut u32,
-        high: *mut u32,
-    ) -> i32;
-    pub fn sceKernelGetSystemTime(time: *mut SceKernelSysClock) -> i32;
-    pub fn sceKernelGetSystemTimeWide() -> i64;
-    pub fn sceKernelGetSystemTimeLow() -> u32;
-    pub fn sceKernelCreateVTimer(
-        name: *const u8,
-        opt: *mut SceKernelVTimerOptParam,
-    ) -> SceUid;
-    pub fn sceKernelDeleteVTimer(uid: SceUid) -> i32;
-    pub fn sceKernelGetVTimerBase(
-        uid: SceUid,
-        base: *mut SceKernelSysClock,
-    ) -> i32;
-    pub fn sceKernelGetVTimerBaseWide(uid: SceUid) -> i64;
-    pub fn sceKernelGetVTimerTime(
-        uid: SceUid,
-        time: *mut SceKernelSysClock,
-    ) -> i32;
-    pub fn sceKernelGetVTimerTimeWide(uid: SceUid) -> i64;
-    pub fn sceKernelSetVTimerTime(
-        uid: SceUid,
-        time: *mut SceKernelSysClock,
-    ) -> i32;
-    pub fn sceKernelSetVTimerTimeWide(uid: SceUid, time: i64) -> i64;
-    pub fn sceKernelStartVTimer(uid: SceUid) -> i32;
-    pub fn sceKernelStopVTimer(uid: SceUid) -> i32;
-    pub fn sceKernelSetVTimerHandler(
-        uid: SceUid,
-        time: *mut SceKernelSysClock,
-        handler: SceKernelVTimerHandler,
-        common: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelSetVTimerHandlerWide(
-        uid: SceUid,
-        time: i64,
-        handler: SceKernelVTimerHandlerWide,
-        common: *mut c_void,
-    ) -> i32;
-    pub fn sceKernelCancelVTimerHandler(uid: SceUid) -> i32;
-    pub fn sceKernelReferVTimerStatus(
-        uid: SceUid,
-        info: *mut SceKernelVTimerInfo,
-    ) -> i32;
-    pub fn sceKernelRegisterThreadEventHandler(
-        name: *const u8,
-        thread_id: SceUid,
-        mask: i32,
-        handler: SceKernelThreadEventHandler,
-        common: *mut c_void,
-    ) -> SceUid;
-    pub fn sceKernelReleaseThreadEventHandler(uid: SceUid) -> i32;
-    pub fn sceKernelReferThreadEventHandlerStatus(
-        uid: SceUid,
-        info: *mut SceKernelThreadEventHandlerInfo,
-    ) -> i32;
-    pub fn sceKernelReferThreadProfiler() -> *mut DebugProfilerRegs;
-    pub fn sceKernelReferGlobalProfiler() -> *mut DebugProfilerRegs;
-}
diff --git a/src/psp/mod.rs b/src/psp/mod.rs
deleted file mode 100644
index 5a647a4468..0000000000
--- a/src/psp/mod.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-//! PSP C type definitions
-//!
-//! These type declarations are not enough, as they must be ultimately resolved
-//! by the linker. Crates that use these definitions must, somewhere in the
-//! crate graph, include a stub provider crate such as the `psp` crate.
-
-pub type c_schar = i8;
-pub type c_uchar = u8;
-pub type c_short = i16;
-pub type c_ushort = u16;
-pub type c_int = i32;
-pub type c_uint = u32;
-pub type c_float = f32;
-pub type c_double = f64;
-pub type c_longlong = i64;
-pub type c_ulonglong = u64;
-pub type intmax_t = i64;
-pub type uintmax_t = u64;
-
-pub type size_t = usize;
-pub type ptrdiff_t = isize;
-pub type intptr_t = isize;
-pub type uintptr_t = usize;
-pub type ssize_t = isize;
-
-pub type c_char = u8;
-pub type c_long = i64;
-pub type c_ulong = u64;
-
-pub const INT_MIN: c_int = -2147483648;
-pub const INT_MAX: c_int = 2147483647;
-
-cfg_if! {
-    if #[cfg(libc_core_cvoid)] {
-        pub use ::ffi::c_void;
-    } else {
-        // Use repr(u8) as LLVM expects `void*` to be the same as `i8*` to help
-        // enable more optimization opportunities around it recognizing things
-        // like malloc/free.
-        #[repr(u8)]
-        #[allow(missing_copy_implementations)]
-        #[allow(missing_debug_implementations)]
-        pub enum c_void {
-            // Two dummy variants so the #[repr] attribute can be used.
-            #[doc(hidden)]
-            __variant1,
-            #[doc(hidden)]
-            __variant2,
-        }
-    }
-}
-
-mod audio;
-pub use self::audio::*;
-
-mod atrac;
-pub use self::atrac::*;
-
-mod ctrl;
-pub use self::ctrl::*;
-
-mod display;
-pub use self::display::*;
-
-mod ge;
-pub use self::ge::*;
-
-mod kernel;
-pub use self::kernel::*;
-
-mod usb;
-pub use self::usb::*;
-
-mod power;
-pub use self::power::*;
-
-mod wlan;
-pub use self::wlan::*;
-
-mod rtc;
-pub use self::rtc::*;
-
-mod io;
-pub use self::io::*;
-
-mod jpeg;
-pub use self::jpeg::*;
-
-mod umd;
-pub use self::umd::*;
-
-mod mpeg;
-pub use self::mpeg::*;
-
-mod hprm;
-pub use self::hprm::*;
-
-mod gu;
-pub use self::gu::*;
-
-mod gum;
-pub use self::gum::*;
-
-mod types;
-pub use self::types::*;
-
-mod mp3;
-pub use self::mp3::*;
-
-mod registry;
-pub use self::registry::*;
-
-mod openpsid;
-pub use self::openpsid::*;
-
-mod utility;
-pub use self::utility::*;
-
-mod net;
-pub use self::net::*;
diff --git a/src/psp/mp3.rs b/src/psp/mp3.rs
deleted file mode 100644
index 25d4787f0e..0000000000
--- a/src/psp/mp3.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use super::c_void;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceMp3InitArg {
-    pub mp3_stream_start: u32,
-    pub unk1: u32,
-    pub mp3_stream_end: u32,
-    pub unk2: u32,
-    pub mp3_buf: *mut c_void,
-    pub mp3_buf_size: i32,
-    pub pcm_buf: *mut c_void,
-    pub pcm_buf_size: i32,
-}
-
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct Handle(pub i32);
-
-extern "C" {
-    pub fn sceMp3ReserveMp3Handle(args: *mut SceMp3InitArg) -> i32;
-    pub fn sceMp3ReleaseMp3Handle(handle: Handle) -> i32;
-    pub fn sceMp3InitResource() -> i32;
-    pub fn sceMp3TermResource() -> i32;
-    pub fn sceMp3Init(handle: Handle) -> i32;
-    pub fn sceMp3Decode(handle: Handle, dst: *mut *mut i16) -> i32;
-    pub fn sceMp3GetInfoToAddStreamData(
-        handle: Handle,
-        dst: *mut *mut u8,
-        to_write: *mut i32,
-        src_pos: *mut i32,
-    ) -> i32;
-    pub fn sceMp3NotifyAddStreamData(handle: Handle, size: i32) -> i32;
-    pub fn sceMp3CheckStreamDataNeeded(handle: Handle) -> i32;
-    pub fn sceMp3SetLoopNum(handle: Handle, loop_: i32) -> i32;
-    pub fn sceMp3GetLoopNum(handle: Handle) -> i32;
-    pub fn sceMp3GetSumDecodedSample(handle: Handle) -> i32;
-    pub fn sceMp3GetMaxOutputSample(handle: Handle) -> i32;
-    pub fn sceMp3GetSamplingRate(handle: Handle) -> i32;
-    pub fn sceMp3GetBitRate(handle: Handle) -> i32;
-    pub fn sceMp3GetMp3ChannelNum(handle: Handle) -> i32;
-    pub fn sceMp3ResetPlayPosition(handle: Handle) -> i32;
-}
diff --git a/src/psp/mpeg.rs b/src/psp/mpeg.rs
deleted file mode 100644
index 8ce889b3ab..0000000000
--- a/src/psp/mpeg.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-use super::c_void;
-
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct SceMpeg(*mut *mut c_void);
-
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct SceMpegStream(*mut c_void);
-pub type SceMpegRingbufferCb = Option<
-    unsafe extern "C" fn(
-        data: *mut c_void,
-        num_packets: i32,
-        param: *mut c_void,
-    ) -> i32,
->;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceMpegRingbuffer {
-    pub packets: i32,
-    pub unk0: u32,
-    pub unk1: u32,
-    pub unk2: u32,
-    pub unk3: u32,
-    pub data: *mut c_void,
-    pub callback: SceMpegRingbufferCb,
-    pub cb_param: *mut c_void,
-    pub unk4: u32,
-    pub unk5: u32,
-    pub sce_mpeg: *mut c_void,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceMpegAu {
-    pub pts_msb: u32,
-    pub pts: u32,
-    pub dts_msb: u32,
-    pub dts: u32,
-    pub es_buffer: u32,
-    pub au_size: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceMpegAvcMode {
-    pub unk0: i32,
-    pub pixel_format: super::DisplayPixelFormat,
-}
-
-extern "C" {
-    pub fn sceMpegInit() -> i32;
-    pub fn sceMpegFinish();
-    pub fn sceMpegRingbufferQueryMemSize(packets: i32) -> i32;
-    pub fn sceMpegRingbufferConstruct(
-        ringbuffer: *mut SceMpegRingbuffer,
-        packets: i32,
-        data: *mut c_void,
-        size: i32,
-        callback: SceMpegRingbufferCb,
-        cb_param: *mut c_void,
-    ) -> i32;
-    pub fn sceMpegRingbufferDestruct(ringbuffer: *mut SceMpegRingbuffer);
-    pub fn sceMpegRingbufferAvailableSize(
-        ringbuffer: *mut SceMpegRingbuffer,
-    ) -> i32;
-    pub fn sceMpegRingbufferPut(
-        ringbuffer: *mut SceMpegRingbuffer,
-        num_packets: i32,
-        available: i32,
-    ) -> i32;
-    pub fn sceMpegQueryMemSize(unk: i32) -> i32;
-    pub fn sceMpegCreate(
-        handle: SceMpeg,
-        data: *mut c_void,
-        size: i32,
-        ringbuffer: *mut SceMpegRingbuffer,
-        frame_width: i32,
-        unk1: i32,
-        unk2: i32,
-    ) -> i32;
-    pub fn sceMpegDelete(handle: SceMpeg);
-    pub fn sceMpegQueryStreamOffset(
-        handle: SceMpeg,
-        buffer: *mut c_void,
-        offset: *mut i32,
-    ) -> i32;
-    pub fn sceMpegQueryStreamSize(buffer: *mut c_void, size: *mut i32) -> i32;
-    pub fn sceMpegRegistStream(
-        handle: SceMpeg,
-        stream_id: i32,
-        unk: i32,
-    ) -> SceMpegStream;
-    pub fn sceMpegUnRegistStream(handle: SceMpeg, stream: SceMpegStream);
-    pub fn sceMpegFlushAllStream(handle: SceMpeg) -> i32;
-    pub fn sceMpegMallocAvcEsBuf(handle: SceMpeg) -> *mut c_void;
-    pub fn sceMpegFreeAvcEsBuf(handle: SceMpeg, buf: *mut c_void);
-    pub fn sceMpegQueryAtracEsSize(
-        handle: SceMpeg,
-        es_size: *mut i32,
-        out_size: *mut i32,
-    ) -> i32;
-    pub fn sceMpegInitAu(
-        handle: SceMpeg,
-        es_buffer: *mut c_void,
-        au: *mut SceMpegAu,
-    ) -> i32;
-    pub fn sceMpegGetAvcAu(
-        handle: SceMpeg,
-        stream: SceMpegStream,
-        au: *mut SceMpegAu,
-        unk: *mut i32,
-    ) -> i32;
-    pub fn sceMpegAvcDecodeMode(
-        handle: SceMpeg,
-        mode: *mut SceMpegAvcMode,
-    ) -> i32;
-    pub fn sceMpegAvcDecode(
-        handle: SceMpeg,
-        au: *mut SceMpegAu,
-        iframe_width: i32,
-        buffer: *mut c_void,
-        init: *mut i32,
-    ) -> i32;
-    pub fn sceMpegAvcDecodeStop(
-        handle: SceMpeg,
-        frame_width: i32,
-        buffer: *mut c_void,
-        status: *mut i32,
-    ) -> i32;
-    pub fn sceMpegGetAtracAu(
-        handle: SceMpeg,
-        stream: SceMpegStream,
-        au: *mut SceMpegAu,
-        unk: *mut c_void,
-    ) -> i32;
-    pub fn sceMpegAtracDecode(
-        handle: SceMpeg,
-        au: *mut SceMpegAu,
-        buffer: *mut c_void,
-        init: i32,
-    ) -> i32;
-}
-
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct SceMpegLLI {
-    pub src: *mut c_void,
-    pub dst: *mut c_void,
-    pub next: *mut c_void,
-    pub size: i32,
-}
-
-#[repr(C)]
-#[repr(align(64))]
-#[derive(Copy, Clone)]
-pub struct SceMpegYCrCbBuffer {
-    pub frame_buffer_height16: i32,
-    pub frame_buffer_width16: i32,
-    pub unknown: i32,
-    pub unknown2: i32,
-    pub y_buffer: *mut c_void,
-    pub y_buffer2: *mut c_void,
-    pub cr_buffer: *mut c_void,
-    pub cb_buffer: *mut c_void,
-    pub cr_buffer2: *mut c_void,
-    pub cb_buffer2: *mut c_void,
-
-    pub frame_height: i32,
-    pub frame_width: i32,
-    pub frame_buffer_width: i32,
-    pub unknown3: [i32; 11usize],
-}
-
-extern "C" {
-    pub fn sceMpegBaseYCrCbCopyVme(
-        yuv_buffer: *mut c_void,
-        buffer: *mut i32,
-        type_: i32,
-    ) -> i32;
-    pub fn sceMpegBaseCscInit(width: i32) -> i32;
-    pub fn sceMpegBaseCscVme(
-        rgb_buffer: *mut c_void,
-        rgb_buffer2: *mut c_void,
-        width: i32,
-        y_cr_cb_buffer: *mut SceMpegYCrCbBuffer,
-    ) -> i32;
-    pub fn sceMpegbase_BEA18F91(lli: *mut SceMpegLLI) -> i32;
-}
diff --git a/src/psp/nand.rs b/src/psp/nand.rs
deleted file mode 100644
index 53acd94617..0000000000
--- a/src/psp/nand.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use super::c_void;
-extern "C" {
-    pub fn sceNandSetWriteProtect(protect_flag: i32) -> i32;
-    pub fn sceNandLock(write_flag: i32) -> i32;
-    pub fn sceNandUnlock();
-    pub fn sceNandReadStatus() -> i32;
-    pub fn sceNandReset(flag: i32) -> i32;
-    pub fn sceNandReadId(buf: *mut c_void, size: usize) -> i32;
-    pub fn sceNandReadPages(
-        ppn: u32,
-        buf: *mut c_void,
-        buf2: *mut c_void,
-        count: u32,
-    ) -> i32;
-    pub fn sceNandGetPageSize() -> i32;
-    pub fn sceNandGetPagesPerBlock() -> i32;
-    pub fn sceNandGetTotalBlocks() -> i32;
-    pub fn sceNandReadBlockWithRetry(
-        ppn: u32,
-        buf: *mut c_void,
-        buf2: *mut c_void,
-    ) -> i32;
-    pub fn sceNandIsBadBlock(ppn: u32) -> i32;
-}
diff --git a/src/psp/net.rs b/src/psp/net.rs
deleted file mode 100644
index da578d67a3..0000000000
--- a/src/psp/net.rs
+++ /dev/null
@@ -1,734 +0,0 @@
-use super::c_void;
-
-pub type SceNetAdhocctlHandler =
-    Option<unsafe extern "C" fn(flag: i32, error: i32, unknown: *mut c_void)>;
-
-pub type AdhocMatchingCallback = Option<
-    unsafe extern "C" fn(
-        matching_id: i32,
-        event: i32,
-        mac: *mut u8,
-        opt_len: i32,
-        opt_data: *mut c_void,
-    ),
->;
-
-pub type SceNetApctlHandler = Option<
-    unsafe extern "C" fn(
-        oldState: i32,
-        newState: i32,
-        event: i32,
-        error: i32,
-        pArg: *mut c_void,
-    ),
->;
-
-pub type HttpMallocFunction =
-    Option<unsafe extern "C" fn(size: usize) -> *mut c_void>;
-pub type HttpReallocFunction =
-    Option<unsafe extern "C" fn(p: *mut c_void, size: usize) -> *mut c_void>;
-pub type HttpFreeFunction = Option<unsafe extern "C" fn(p: *mut c_void)>;
-pub type HttpPasswordCB = Option<
-    unsafe extern "C" fn(
-        request: i32,
-        auth_type: HttpAuthType,
-        realm: *const u8,
-        username: *mut u8,
-        password: *mut u8,
-        need_entity: i32,
-        entity_body: *mut *mut u8,
-        entity_size: *mut usize,
-        save: *mut i32,
-    ) -> i32,
->;
-
-#[allow(non_camel_case_types)]
-pub type socklen_t = u32;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetMallocStat {
-    pub pool: i32,
-    pub maximum: i32,
-    pub free: i32,
-}
-
-extern "C" {
-    pub fn sceNetInit(
-        poolsize: i32,
-        calloutprio: i32,
-        calloutstack: i32,
-        netintrprio: i32,
-        netintrstack: i32,
-    ) -> i32;
-    pub fn sceNetTerm() -> i32;
-    pub fn sceNetFreeThreadinfo(thid: i32) -> i32;
-    pub fn sceNetThreadAbort(thid: i32) -> i32;
-    pub fn sceNetEtherStrton(name: *mut u8, mac: *mut u8);
-    pub fn sceNetEtherNtostr(mac: *mut u8, name: *mut u8);
-    pub fn sceNetGetLocalEtherAddr(mac: *mut u8) -> i32;
-    pub fn sceNetGetMallocStat(stat: *mut SceNetMallocStat) -> i32;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocctlAdhocId {
-    pub unknown: i32,
-    pub adhoc_id: [u8; 9usize],
-    pub unk: [u8; 3usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocctlPeerInfo {
-    pub next: *mut SceNetAdhocctlPeerInfo,
-    pub nickname: [u8; 128usize],
-    pub mac: [u8; 6usize],
-    pub unknown: [u8; 6usize],
-    pub timestamp: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocctlScanInfo {
-    pub next: *mut SceNetAdhocctlScanInfo,
-    pub channel: i32,
-    pub name: [u8; 8usize],
-    pub bssid: [u8; 6usize],
-    pub unknown: [u8; 2usize],
-    pub unknown2: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocctlGameModeInfo {
-    pub count: i32,
-    pub macs: [[u8; 6usize]; 16usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocctlParams {
-    pub channel: i32,
-    pub name: [u8; 8usize],
-    pub bssid: [u8; 6usize],
-    pub nickname: [u8; 128usize],
-}
-
-extern "C" {
-    pub fn sceNetAdhocctlInit(
-        stacksize: i32,
-        priority: i32,
-        adhoc_id: *mut SceNetAdhocctlAdhocId,
-    ) -> i32;
-    pub fn sceNetAdhocctlTerm() -> i32;
-    pub fn sceNetAdhocctlConnect(name: *const u8) -> i32;
-    pub fn sceNetAdhocctlDisconnect() -> i32;
-    pub fn sceNetAdhocctlGetState(event: *mut i32) -> i32;
-    pub fn sceNetAdhocctlCreate(name: *const u8) -> i32;
-    pub fn sceNetAdhocctlJoin(scaninfo: *mut SceNetAdhocctlScanInfo) -> i32;
-    pub fn sceNetAdhocctlGetAdhocId(id: *mut SceNetAdhocctlAdhocId) -> i32;
-    pub fn sceNetAdhocctlCreateEnterGameMode(
-        name: *const u8,
-        unknown: i32,
-        num: i32,
-        macs: *mut u8,
-        timeout: u32,
-        unknown2: i32,
-    ) -> i32;
-    pub fn sceNetAdhocctlJoinEnterGameMode(
-        name: *const u8,
-        hostmac: *mut u8,
-        timeout: u32,
-        unknown: i32,
-    ) -> i32;
-    pub fn sceNetAdhocctlGetGameModeInfo(
-        gamemodeinfo: *mut SceNetAdhocctlGameModeInfo,
-    ) -> i32;
-    pub fn sceNetAdhocctlExitGameMode() -> i32;
-    pub fn sceNetAdhocctlGetPeerList(
-        length: *mut i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocctlGetPeerInfo(
-        mac: *mut u8,
-        size: i32,
-        peerinfo: *mut SceNetAdhocctlPeerInfo,
-    ) -> i32;
-    pub fn sceNetAdhocctlScan() -> i32;
-    pub fn sceNetAdhocctlGetScanInfo(
-        length: *mut i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocctlAddHandler(
-        handler: SceNetAdhocctlHandler,
-        unknown: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocctlDelHandler(id: i32) -> i32;
-    pub fn sceNetAdhocctlGetNameByAddr(mac: *mut u8, nickname: *mut u8)
-        -> i32;
-    pub fn sceNetAdhocctlGetAddrByName(
-        nickname: *mut u8,
-        length: *mut i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocctlGetParameter(
-        params: *mut SceNetAdhocctlParams,
-    ) -> i32;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocPtpStat {
-    pub next: *mut SceNetAdhocPtpStat,
-    pub ptp_id: i32,
-    pub mac: [u8; 6usize],
-    pub peermac: [u8; 6usize],
-    pub port: u16,
-    pub peerport: u16,
-    pub sent_data: u32,
-    pub rcvd_data: u32,
-    pub state: ScePspnetAdhocPtpState,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum ScePspnetAdhocPtpState {
-    Closed,
-    Listen,
-    SynSent,
-    SynReceived,
-    Established,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceNetAdhocPdpStat {
-    pub next: *mut SceNetAdhocPdpStat,
-    pub pdp_id: i32,
-    pub mac: [u8; 6usize],
-    pub port: u16,
-    pub rcvd_data: u32,
-}
-
-extern "C" {
-    pub fn sceNetAdhocInit() -> i32;
-    pub fn sceNetAdhocTerm() -> i32;
-    pub fn sceNetAdhocPdpCreate(
-        mac: *mut u8,
-        port: u16,
-        buf_size: u32,
-        unk1: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPdpDelete(id: i32, unk1: i32) -> i32;
-    pub fn sceNetAdhocPdpSend(
-        id: i32,
-        dest_mac_addr: *mut u8,
-        port: u16,
-        data: *mut c_void,
-        len: u32,
-        timeout: u32,
-        nonblock: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPdpRecv(
-        id: i32,
-        src_mac_addr: *mut u8,
-        port: *mut u16,
-        data: *mut c_void,
-        data_length: *mut c_void,
-        timeout: u32,
-        nonblock: i32,
-    ) -> i32;
-    pub fn sceNetAdhocGetPdpStat(
-        size: *mut i32,
-        stat: *mut SceNetAdhocPdpStat,
-    ) -> i32;
-    pub fn sceNetAdhocGameModeCreateMaster(
-        data: *mut c_void,
-        size: i32,
-    ) -> i32;
-    pub fn sceNetAdhocGameModeCreateReplica(
-        mac: *mut u8,
-        data: *mut c_void,
-        size: i32,
-    ) -> i32;
-    pub fn sceNetAdhocGameModeUpdateMaster() -> i32;
-    pub fn sceNetAdhocGameModeUpdateReplica(id: i32, unk1: i32) -> i32;
-    pub fn sceNetAdhocGameModeDeleteMaster() -> i32;
-    pub fn sceNetAdhocGameModeDeleteReplica(id: i32) -> i32;
-    pub fn sceNetAdhocPtpOpen(
-        srcmac: *mut u8,
-        srcport: u16,
-        destmac: *mut u8,
-        destport: u16,
-        buf_size: u32,
-        delay: u32,
-        count: i32,
-        unk1: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPtpConnect(id: i32, timeout: u32, nonblock: i32) -> i32;
-    pub fn sceNetAdhocPtpListen(
-        srcmac: *mut u8,
-        srcport: u16,
-        buf_size: u32,
-        delay: u32,
-        count: i32,
-        queue: i32,
-        unk1: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPtpAccept(
-        id: i32,
-        mac: *mut u8,
-        port: *mut u16,
-        timeout: u32,
-        nonblock: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPtpSend(
-        id: i32,
-        data: *mut c_void,
-        data_size: *mut i32,
-        timeout: u32,
-        nonblock: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPtpRecv(
-        id: i32,
-        data: *mut c_void,
-        data_size: *mut i32,
-        timeout: u32,
-        nonblock: i32,
-    ) -> i32;
-    pub fn sceNetAdhocPtpFlush(id: i32, timeout: u32, nonblock: i32) -> i32;
-    pub fn sceNetAdhocPtpClose(id: i32, unk1: i32) -> i32;
-    pub fn sceNetAdhocGetPtpStat(
-        size: *mut i32,
-        stat: *mut SceNetAdhocPtpStat,
-    ) -> i32;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct AdhocPoolStat {
-    pub size: i32,
-    pub maxsize: i32,
-    pub freesize: i32,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum AdhocMatchingMode {
-    Host = 1,
-    Client,
-    Ptp,
-}
-
-extern "C" {
-    pub fn sceNetAdhocMatchingInit(memsize: i32) -> i32;
-    pub fn sceNetAdhocMatchingTerm() -> i32;
-    pub fn sceNetAdhocMatchingCreate(
-        mode: AdhocMatchingMode,
-        max_peers: i32,
-        port: u16,
-        buf_size: i32,
-        hello_delay: u32,
-        ping_delay: u32,
-        init_count: i32,
-        msg_delay: u32,
-        callback: AdhocMatchingCallback,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingDelete(matching_id: i32) -> i32;
-    pub fn sceNetAdhocMatchingStart(
-        matching_id: i32,
-        evth_pri: i32,
-        evth_stack: i32,
-        inth_pri: i32,
-        inth_stack: i32,
-        opt_len: i32,
-        opt_data: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingStop(matching_id: i32) -> i32;
-    pub fn sceNetAdhocMatchingSelectTarget(
-        matching_id: i32,
-        mac: *mut u8,
-        opt_len: i32,
-        opt_data: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingCancelTarget(
-        matching_id: i32,
-        mac: *mut u8,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingCancelTargetWithOpt(
-        matching_id: i32,
-        mac: *mut u8,
-        opt_len: i32,
-        opt_data: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingSendData(
-        matching_id: i32,
-        mac: *mut u8,
-        data_len: i32,
-        data: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingAbortSendData(
-        matching_id: i32,
-        mac: *mut u8,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingSetHelloOpt(
-        matching_id: i32,
-        opt_len: i32,
-        opt_data: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingGetHelloOpt(
-        matching_id: i32,
-        opt_len: *mut i32,
-        opt_data: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingGetMembers(
-        matching_id: i32,
-        length: *mut i32,
-        buf: *mut c_void,
-    ) -> i32;
-    pub fn sceNetAdhocMatchingGetPoolMaxAlloc() -> i32;
-    pub fn sceNetAdhocMatchingGetPoolStat(poolstat: *mut AdhocPoolStat)
-        -> i32;
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum ApctlState {
-    Disconnected,
-    Scanning,
-    Joining,
-    GettingIp,
-    GotIp,
-    EapAuth,
-    KeyExchange,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum ApctlEvent {
-    ConnectRequest,
-    ScanRequest,
-    ScanComplete,
-    Established,
-    GetIp,
-    DisconnectRequest,
-    Error,
-    Info,
-    EapAuth,
-    KeyExchange,
-    Reconnect,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum ApctlInfo {
-    ProfileName,
-    Bssid,
-    Ssid,
-    SsidLength,
-    SecurityType,
-    Strength,
-    Channel,
-    PowerSave,
-    Ip,
-    SubnetMask,
-    Gateway,
-    PrimaryDns,
-    SecondaryDns,
-    UseProxy,
-    ProxyUrl,
-    ProxyPort,
-    EapType,
-    StartBrowser,
-    Wifisp,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum ApctlInfoSecurityType {
-    None,
-    Wep,
-    Wpa,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union SceNetApctlInfo {
-    pub name: [u8; 64usize],
-    pub bssid: [u8; 6usize],
-    pub ssid: [u8; 32usize],
-    pub ssid_length: u32,
-    pub security_type: u32,
-    pub strength: u8,
-    pub channel: u8,
-    pub power_save: u8,
-    pub ip: [u8; 16usize],
-    pub sub_net_mask: [u8; 16usize],
-    pub gateway: [u8; 16usize],
-    pub primary_dns: [u8; 16usize],
-    pub secondary_dns: [u8; 16usize],
-    pub use_proxy: u32,
-    pub proxy_url: [u8; 128usize],
-    pub proxy_port: u16,
-    pub eap_type: u32,
-    pub start_browser: u32,
-    pub wifisp: u32,
-}
-
-extern "C" {
-    pub fn sceNetApctlInit(stack_size: i32, init_priority: i32) -> i32;
-    pub fn sceNetApctlTerm() -> i32;
-    pub fn sceNetApctlGetInfo(
-        code: ApctlInfo,
-        pinfo: *mut SceNetApctlInfo,
-    ) -> i32;
-    pub fn sceNetApctlAddHandler(
-        handler: SceNetApctlHandler,
-        parg: *mut c_void,
-    ) -> i32;
-    pub fn sceNetApctlDelHandler(handler_id: i32) -> i32;
-    pub fn sceNetApctlConnect(conn_index: i32) -> i32;
-    pub fn sceNetApctlDisconnect() -> i32;
-    pub fn sceNetApctlGetState(pstate: *mut ApctlState) -> i32;
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct sockaddr(pub u32);
-
-extern "C" {
-    pub fn sceNetInetInit() -> i32;
-    pub fn sceNetInetTerm() -> i32;
-    pub fn sceNetInetAccept(
-        s: i32,
-        addr: *mut sockaddr,
-        addr_len: *mut socklen_t,
-    ) -> i32;
-    pub fn sceNetInetBind(
-        s: i32,
-        my_addr: *const sockaddr,
-        addr_len: socklen_t,
-    ) -> i32;
-    pub fn sceNetInetConnect(
-        s: i32,
-        serv_addr: *const sockaddr,
-        addr_len: socklen_t,
-    ) -> i32;
-    pub fn sceNetInetGetsockopt(
-        s: i32,
-        level: i32,
-        opt_name: i32,
-        opt_val: *mut c_void,
-        optl_en: *mut socklen_t,
-    ) -> i32;
-    pub fn sceNetInetListen(s: i32, backlog: i32) -> i32;
-    pub fn sceNetInetRecv(
-        s: i32,
-        buf: *mut c_void,
-        len: usize,
-        flags: i32,
-    ) -> usize;
-    pub fn sceNetInetRecvfrom(
-        s: i32,
-        buf: *mut c_void,
-        flags: usize,
-        arg1: i32,
-        from: *mut sockaddr,
-        from_len: *mut socklen_t,
-    ) -> usize;
-    pub fn sceNetInetSend(
-        s: i32,
-        buf: *const c_void,
-        len: usize,
-        flags: i32,
-    ) -> usize;
-    pub fn sceNetInetSendto(
-        s: i32,
-        buf: *const c_void,
-        len: usize,
-        flags: i32,
-        to: *const sockaddr,
-        to_len: socklen_t,
-    ) -> usize;
-    pub fn sceNetInetSetsockopt(
-        s: i32,
-        level: i32,
-        opt_name: i32,
-        opt_val: *const c_void,
-        opt_len: socklen_t,
-    ) -> i32;
-    pub fn sceNetInetShutdown(s: i32, how: i32) -> i32;
-    pub fn sceNetInetSocket(domain: i32, type_: i32, protocol: i32) -> i32;
-    pub fn sceNetInetClose(s: i32) -> i32;
-    pub fn sceNetInetGetErrno() -> i32;
-}
-
-extern "C" {
-    pub fn sceSslInit(unknown1: i32) -> i32;
-    pub fn sceSslEnd() -> i32;
-    pub fn sceSslGetUsedMemoryMax(memory: *mut u32) -> i32;
-    pub fn sceSslGetUsedMemoryCurrent(memory: *mut u32) -> i32;
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum HttpMethod {
-    Get,
-    Post,
-    Head,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum HttpAuthType {
-    Basic,
-    Digest,
-}
-
-extern "C" {
-    pub fn sceHttpInit(unknown1: u32) -> i32;
-    pub fn sceHttpEnd() -> i32;
-    pub fn sceHttpCreateTemplate(
-        agent: *mut u8,
-        unknown1: i32,
-        unknown2: i32,
-    ) -> i32;
-    pub fn sceHttpDeleteTemplate(templateid: i32) -> i32;
-    pub fn sceHttpCreateConnection(
-        templateid: i32,
-        host: *mut u8,
-        unknown1: *mut u8,
-        port: u16,
-        unknown2: i32,
-    ) -> i32;
-    pub fn sceHttpCreateConnectionWithURL(
-        templateid: i32,
-        url: *const u8,
-        unknown1: i32,
-    ) -> i32;
-    pub fn sceHttpDeleteConnection(connection_id: i32) -> i32;
-    pub fn sceHttpCreateRequest(
-        connection_id: i32,
-        method: HttpMethod,
-        path: *mut u8,
-        content_length: u64,
-    ) -> i32;
-    pub fn sceHttpCreateRequestWithURL(
-        connection_id: i32,
-        method: HttpMethod,
-        url: *mut u8,
-        content_length: u64,
-    ) -> i32;
-    pub fn sceHttpDeleteRequest(request_id: i32) -> i32;
-    pub fn sceHttpSendRequest(
-        request_id: i32,
-        data: *mut c_void,
-        data_size: u32,
-    ) -> i32;
-    pub fn sceHttpAbortRequest(request_id: i32) -> i32;
-    pub fn sceHttpReadData(
-        request_id: i32,
-        data: *mut c_void,
-        data_size: u32,
-    ) -> i32;
-    pub fn sceHttpGetContentLength(
-        request_id: i32,
-        content_length: *mut u64,
-    ) -> i32;
-    pub fn sceHttpGetStatusCode(request_id: i32, status_code: *mut i32)
-        -> i32;
-    pub fn sceHttpSetResolveTimeOut(id: i32, timeout: u32) -> i32;
-    pub fn sceHttpSetResolveRetry(id: i32, count: i32) -> i32;
-    pub fn sceHttpSetConnectTimeOut(id: i32, timeout: u32) -> i32;
-    pub fn sceHttpSetSendTimeOut(id: i32, timeout: u32) -> i32;
-    pub fn sceHttpSetRecvTimeOut(id: i32, timeout: u32) -> i32;
-    pub fn sceHttpEnableKeepAlive(id: i32) -> i32;
-    pub fn sceHttpDisableKeepAlive(id: i32) -> i32;
-    pub fn sceHttpEnableRedirect(id: i32) -> i32;
-    pub fn sceHttpDisableRedirect(id: i32) -> i32;
-    pub fn sceHttpEnableCookie(id: i32) -> i32;
-    pub fn sceHttpDisableCookie(id: i32) -> i32;
-    pub fn sceHttpSaveSystemCookie() -> i32;
-    pub fn sceHttpLoadSystemCookie() -> i32;
-    pub fn sceHttpAddExtraHeader(
-        id: i32,
-        name: *mut u8,
-        value: *mut u8,
-        unknown1: i32,
-    ) -> i32;
-    pub fn sceHttpDeleteHeader(id: i32, name: *const u8) -> i32;
-    pub fn sceHttpsInit(
-        unknown1: i32,
-        unknown2: i32,
-        unknown3: i32,
-        unknown4: i32,
-    ) -> i32;
-    pub fn sceHttpsEnd() -> i32;
-    pub fn sceHttpsLoadDefaultCert(unknown1: i32, unknown2: i32) -> i32;
-    pub fn sceHttpDisableAuth(id: i32) -> i32;
-    pub fn sceHttpDisableCache(id: i32) -> i32;
-    pub fn sceHttpEnableAuth(id: i32) -> i32;
-    pub fn sceHttpEnableCache(id: i32) -> i32;
-    pub fn sceHttpEndCache() -> i32;
-    pub fn sceHttpGetAllHeader(
-        request: i32,
-        header: *mut *mut u8,
-        header_size: *mut u32,
-    ) -> i32;
-    pub fn sceHttpGetNetworkErrno(request: i32, err_num: *mut i32) -> i32;
-    pub fn sceHttpGetProxy(
-        id: i32,
-        activate_flag: *mut i32,
-        mode: *mut i32,
-        proxy_host: *mut u8,
-        len: usize,
-        proxy_port: *mut u16,
-    ) -> i32;
-    pub fn sceHttpInitCache(max_size: usize) -> i32;
-    pub fn sceHttpSetAuthInfoCB(id: i32, cbfunc: HttpPasswordCB) -> i32;
-    pub fn sceHttpSetProxy(
-        id: i32,
-        activate_flag: i32,
-        mode: i32,
-        new_proxy_host: *const u8,
-        new_proxy_port: u16,
-    ) -> i32;
-    pub fn sceHttpSetResHeaderMaxSize(id: i32, header_size: u32) -> i32;
-    pub fn sceHttpSetMallocFunction(
-        malloc_func: HttpMallocFunction,
-        free_func: HttpFreeFunction,
-        realloc_func: HttpReallocFunction,
-    ) -> i32;
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct in_addr(pub u32);
-
-extern "C" {
-    pub fn sceNetResolverInit() -> i32;
-    pub fn sceNetResolverCreate(
-        rid: *mut i32,
-        buf: *mut c_void,
-        buf_length: u32,
-    ) -> i32;
-    pub fn sceNetResolverDelete(rid: i32) -> i32;
-    pub fn sceNetResolverStartNtoA(
-        rid: i32,
-        hostname: *const u8,
-        addr: *mut in_addr,
-        timeout: u32,
-        retry: i32,
-    ) -> i32;
-    pub fn sceNetResolverStartAtoN(
-        rid: i32,
-        addr: *const in_addr,
-        hostname: *mut u8,
-        hostname_len: u32,
-        timeout: u32,
-        retry: i32,
-    ) -> i32;
-    pub fn sceNetResolverStop(rid: i32) -> i32;
-    pub fn sceNetResolverTerm() -> i32;
-}
diff --git a/src/psp/openpsid.rs b/src/psp/openpsid.rs
deleted file mode 100644
index 21b6e91edf..0000000000
--- a/src/psp/openpsid.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct OpenPSID {
-    pub data: [u8; 16usize],
-}
-
-extern "C" {
-    pub fn sceOpenPSIDGetOpenPSID(openpsid: *mut OpenPSID) -> i32;
-}
diff --git a/src/psp/power.rs b/src/psp/power.rs
deleted file mode 100644
index 910cc1701b..0000000000
--- a/src/psp/power.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use super::SceUid;
-
-pub type PowerCallback = extern "C" fn(unknown: i32, power_info: i32);
-
-pub const POWER_INFO_POWER_SWITCH: i32 = 0x80000000;
-pub const POWER_INFO_HOLD_SWITCH: i32 = 0x40000000;
-pub const POWER_INFO_STANDBY: i32 = 0x00080000;
-pub const POWER_INFO_RESUME_COMPLETE: i32 = 0x00040000;
-pub const POWER_INFO_RESUMING: i32 = 0x00020000;
-pub const POWER_INFO_SUSPENDING: i32 = 0x00010000;
-pub const POWER_INFO_AC_POWER: i32 = 0x00001000;
-pub const POWER_INFO_BATTERY_LOW: i32 = 0x00000100;
-pub const POWER_INFO_BATTERY_EXIST: i32 = 0x00000080;
-pub const POWER_INFO_BATTERY_POWER: i32 = 0x0000007;
-
-#[derive(Copy, Clone)]
-#[repr(u32)]
-pub enum PowerTick {
-    All = 0,
-    Suspend = 1,
-    Display = 6,
-}
-
-extern "C" {
-    pub fn scePowerRegisterCallback(slot: i32, cbid: SceUid) -> i32;
-    pub fn scePowerUnregisterCallback(slot: i32) -> i32;
-    pub fn scePowerIsPowerOnline() -> i32;
-    pub fn scePowerIsBatteryExist() -> i32;
-    pub fn scePowerIsBatteryCharging() -> i32;
-    pub fn scePowerGetBatteryChargingStatus() -> i32;
-    pub fn scePowerIsLowBattery() -> i32;
-    pub fn scePowerGetBatteryLifePercent() -> i32;
-    pub fn scePowerGetBatteryLifeTime() -> i32;
-    pub fn scePowerGetBatteryTemp() -> i32;
-    pub fn scePowerGetBatteryElec() -> i32;
-    pub fn scePowerGetBatteryVolt() -> i32;
-    pub fn scePowerSetCpuClockFrequency(cpufreq: i32) -> i32;
-    pub fn scePowerSetBusClockFrequency(busfreq: i32) -> i32;
-    pub fn scePowerGetCpuClockFrequency() -> i32;
-    pub fn scePowerGetCpuClockFrequencyInt() -> i32;
-    pub fn scePowerGetCpuClockFrequencyFloat() -> f32;
-    pub fn scePowerGetBusClockFrequency() -> i32;
-    pub fn scePowerGetBusClockFrequencyInt() -> i32;
-    pub fn scePowerGetBusClockFrequencyFloat() -> f32;
-    pub fn scePowerSetClockFrequency(
-        pllfreq: i32,
-        cpufreq: i32,
-        busfreq: i32,
-    ) -> i32;
-    pub fn scePowerLock(unknown: i32) -> i32;
-    pub fn scePowerUnlock(unknown: i32) -> i32;
-    pub fn scePowerTick(t: PowerTick) -> i32;
-    pub fn scePowerGetIdleTimer() -> i32;
-    pub fn scePowerIdleTimerEnable(unknown: i32) -> i32;
-    pub fn scePowerIdleTimerDisable(unknown: i32) -> i32;
-    pub fn scePowerRequestStandby() -> i32;
-    pub fn scePowerRequestSuspend() -> i32;
-}
diff --git a/src/psp/registry.rs b/src/psp/registry.rs
deleted file mode 100644
index 49c1ed246d..0000000000
--- a/src/psp/registry.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use super::c_void;
-
-pub const SYSTEM_REGISTRY: [u8; 7] = *b"/system";
-pub const REG_KEYNAME_SIZE: u32 = 27;
-
-#[repr(transparent)]
-#[allow(missing_copy_implementations)]
-pub struct Handle(u32);
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Key {
-    pub key_type: KeyType,
-    pub name: [u8; 256usize],
-    pub name_len: u32,
-    pub unk2: u32,
-    pub unk3: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub enum KeyType {
-    Directory = 1,
-    Integer = 2,
-    String = 3,
-    Bytes = 4,
-}
-
-extern "C" {
-    pub fn sceRegOpenRegistry(
-        reg: *mut Key,
-        mode: i32,
-        handle: *mut Handle,
-    ) -> i32;
-    pub fn sceRegFlushRegistry(handle: Handle) -> i32;
-    pub fn sceRegCloseRegistry(handle: Handle) -> i32;
-    pub fn sceRegOpenCategory(
-        handle: Handle,
-        name: *const u8,
-        mode: i32,
-        dir_handle: *mut Handle,
-    ) -> i32;
-    pub fn sceRegRemoveCategory(
-        handle: Handle,
-        name: *const u8,
-    ) -> i32;
-    pub fn sceRegCloseCategory(dir_handle: Handle) -> i32;
-    pub fn sceRegFlushCategory(dir_handle: Handle) -> i32;
-    pub fn sceRegGetKeyInfo(
-        dir_handle: Handle,
-        name: *const u8,
-        key_handle: *mut Handle,
-        type_: *mut KeyType,
-        size: *mut usize,
-    ) -> i32;
-    pub fn sceRegGetKeyInfoByName(
-        dir_handle: Handle,
-        name: *const u8,
-        type_: *mut KeyType,
-        size: *mut usize,
-    ) -> i32;
-    pub fn sceRegGetKeyValue(
-        dir_handle: Handle,
-        key_handle: Handle,
-        buf: *mut c_void,
-        size: usize,
-    ) -> i32;
-    pub fn sceRegGetKeyValueByName(
-        dir_handle: Handle,
-        name: *const u8,
-        buf: *mut c_void,
-        size: usize,
-    ) -> i32;
-    pub fn sceRegSetKeyValue(
-        dir_handle: Handle,
-        name: *const u8,
-        buf: *const c_void,
-        size: usize,
-    ) -> i32;
-    pub fn sceRegGetKeysNum(
-        dir_handle: Handle,
-        num: *mut i32,
-    ) -> i32;
-    pub fn sceRegGetKeys(
-        dir_handle: Handle,
-        buf: *mut u8,
-        num: i32,
-    ) -> i32;
-    pub fn sceRegCreateKey(
-        dir_handle: Handle,
-        name: *const u8,
-        type_: i32,
-        size: usize,
-    ) -> i32;
-    pub fn sceRegRemoveRegistry(key: *mut Key) -> i32;
-}
diff --git a/src/psp/rtc.rs b/src/psp/rtc.rs
deleted file mode 100644
index ac3295b217..0000000000
--- a/src/psp/rtc.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspDateTime {
-    pub year: u16,
-    pub month: u16,
-    pub day: u16,
-    pub hour: u16,
-    pub minutes: u16,
-    pub seconds: u16,
-    pub microseconds: u32,
-}
-
-#[repr(i32)]
-#[derive(Eq, PartialEq, Copy, Clone)]
-pub enum RtcCheckValidError {
-    InvalidYear = -1,
-    InvalidMonth = -2,
-    InvalidDay = -3,
-    InvalidHour = -4,
-    InvalidMinutes = -5,
-    InvalidSeconds = -6,
-    InvalidMicroseconds = -7,
-}
-
-extern "C" {
-    pub fn sceRtcGetTickResolution() -> u32;
-    pub fn sceRtcGetCurrentTick(tick: *mut u64) -> i32;
-    pub fn sceRtcGetCurrentClock(tm: *mut ScePspDateTime, tz: i32) -> i32;
-    pub fn sceRtcGetCurrentClockLocalTime(tm: *mut ScePspDateTime) -> i32;
-    pub fn sceRtcConvertUtcToLocalTime(
-        tick_utc: *const u64,
-        tick_local: *mut u64,
-    ) -> i32;
-    pub fn sceRtcConvertLocalTimeToUTC(
-        tick_local: *const u64,
-        tick_utc: *mut u64,
-    ) -> i32;
-    pub fn sceRtcIsLeapYear(year: i32) -> i32;
-    pub fn sceRtcGetDaysInMonth(year: i32, month: i32) -> i32;
-    pub fn sceRtcGetDayOfWeek(year: i32, month: i32, day: i32) -> i32;
-    pub fn sceRtcCheckValid(date: *const ScePspDateTime) -> i32;
-    pub fn sceRtcSetTick(date: *mut ScePspDateTime, tick: *const u64) -> i32;
-    pub fn sceRtcGetTick(date: *const ScePspDateTime, tick: *mut u64) -> i32;
-    pub fn sceRtcCompareTick(tick1: *const u64, tick2: *const u64) -> i32;
-    pub fn sceRtcTickAddTicks(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_ticks: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddMicroseconds(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_ms: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddSeconds(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_seconds: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddMinutes(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_minutes: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddHours(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_hours: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddDays(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_days: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddWeeks(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_weeks: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddMonths(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_months: u64,
-    ) -> i32;
-    pub fn sceRtcTickAddYears(
-        dest_tick: *mut u64,
-        src_tick: *const u64,
-        num_years: u64,
-    ) -> i32;
-    pub fn sceRtcSetTime_t(date: *mut ScePspDateTime, time: i64) -> i32;
-    pub fn sceRtcGetTime_t(date: *const ScePspDateTime, time: *mut i64)
-        -> i32;
-    pub fn sceRtcSetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
-    pub fn sceRtcGetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
-    pub fn sceRtcSetWin32FileTime(
-        date: *mut ScePspDateTime,
-        time: *mut u64,
-    ) -> i32;
-    pub fn sceRtcGetWin32FileTime(
-        date: *mut ScePspDateTime,
-        time: *mut u64,
-    ) -> i32;
-    pub fn sceRtcParseDateTime(
-        dest_tick: *mut u64,
-        date_string: *const u8,
-    ) -> i32;
-    pub fn sceRtcFormatRFC3339(
-        psz_date_time: *mut char,
-        p_utc: *const u64,
-        time_zone_minutes: i32,
-    ) -> i32;
-    pub fn sceRtcFormatRFC3339LocalTime(
-        psz_date_time: *mut char,
-        p_utc: *const u64,
-    ) -> i32;
-    pub fn sceRtcParseRFC3339(
-        p_utc: *mut u64,
-        psz_date_time: *const u8,
-    ) -> i32;
-    pub fn sceRtcFormatRFC2822(
-        psz_date_time: *mut char,
-        p_utc: *const u64,
-        time_zone_minutes: i32,
-    ) -> i32;
-    pub fn sceRtcFormatRFC2822LocalTime(
-        psz_date_time: *mut char,
-        p_utc: *const u64,
-    ) -> i32;
-}
diff --git a/src/psp/sircs.rs b/src/psp/sircs.rs
deleted file mode 100644
index 8dd9700455..0000000000
--- a/src/psp/sircs.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SircsData {
-    pub type_: u8,
-    pub cmd: u8,
-    pub dev: u16,
-}
-
-extern "C" {
-    pub fn sceSircsSend(sd: *mut SircsData, count: i32) -> i32;
-}
diff --git a/src/psp/types.rs b/src/psp/types.rs
deleted file mode 100644
index b2243aea3d..0000000000
--- a/src/psp/types.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspSRect {
-    pub x: i16,
-    pub y: i16,
-    pub w: i16,
-    pub h: i16,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIRect {
-    pub x: i32,
-    pub y: i32,
-    pub w: i32,
-    pub h: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspL64Rect {
-    pub x: u64,
-    pub y: u64,
-    pub w: u64,
-    pub h: u64,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspFRect {
-    pub x: f32,
-    pub y: f32,
-    pub w: f32,
-    pub h: f32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspSVector2 {
-    pub x: i16,
-    pub y: i16,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIVector2 {
-    pub x: i32,
-    pub y: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspL64Vector2 {
-    pub x: u64,
-    pub y: u64,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspFVector2 {
-    pub x: f32,
-    pub y: f32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union ScePspVector2 {
-    pub fv: ScePspFVector2,
-    pub iv: ScePspIVector2,
-    pub f: [f32; 2usize],
-    pub i: [i32; 2usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspSVector3 {
-    pub x: i16,
-    pub y: i16,
-    pub z: i16,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIVector3 {
-    pub x: i32,
-    pub y: i32,
-    pub z: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspL64Vector3 {
-    pub x: u64,
-    pub y: u64,
-    pub z: u64,
-}
-#[repr(C, align(16))]
-#[derive(Copy, Clone)]
-pub struct ScePspFVector3 {
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union ScePspVector3 {
-    pub fv: ScePspFVector3,
-    pub iv: ScePspIVector3,
-    pub f: [f32; 3usize],
-    pub i: [i32; 3usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspSVector4 {
-    pub x: i16,
-    pub y: i16,
-    pub z: i16,
-    pub w: i16,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIVector4 {
-    pub x: i32,
-    pub y: i32,
-    pub z: i32,
-    pub w: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspL64Vector4 {
-    pub x: u64,
-    pub y: u64,
-    pub z: u64,
-    pub w: u64,
-}
-
-#[repr(C, align(16))]
-#[derive(Copy, Clone)]
-pub struct ScePspFVector4 {
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-    pub w: f32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspFVector4Unaligned {
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-    pub w: f32,
-}
-
-#[repr(C, align(16))]
-#[derive(Copy, Clone)]
-pub union ScePspVector4 {
-    pub fv: ScePspFVector4,
-    pub iv: ScePspIVector4,
-    pub qw: u128,
-    pub f: [f32; 4usize],
-    pub i: [i32; 4usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIMatrix2 {
-    pub x: ScePspIVector2,
-    pub y: ScePspIVector2,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspFMatrix2 {
-    pub x: ScePspFVector2,
-    pub y: ScePspFVector2,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union ScePspMatrix2 {
-    pub fm: ScePspFMatrix2,
-    pub im: ScePspIMatrix2,
-    pub fv: [ScePspFVector2; 2usize],
-    pub iv: [ScePspIVector2; 2usize],
-    pub v: [ScePspVector2; 2usize],
-    pub f: [[f32; 2usize]; 2usize],
-    pub i: [[i32; 2usize]; 2usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIMatrix3 {
-    pub x: ScePspIVector3,
-    pub y: ScePspIVector3,
-    pub z: ScePspIVector3,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspFMatrix3 {
-    pub x: ScePspFVector3,
-    pub y: ScePspFVector3,
-    pub z: ScePspFVector3,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union ScePspMatrix3 {
-    pub fm: ScePspFMatrix3,
-    pub im: ScePspIMatrix3,
-    pub fv: [ScePspFVector3; 3usize],
-    pub iv: [ScePspIVector3; 3usize],
-    pub v: [ScePspVector3; 3usize],
-    pub f: [[f32; 3usize]; 3usize],
-    pub i: [[i32; 3usize]; 3usize],
-}
-
-#[repr(C, align(16))]
-#[derive(Copy, Clone)]
-pub struct ScePspIMatrix4 {
-    pub x: ScePspIVector4,
-    pub y: ScePspIVector4,
-    pub z: ScePspIVector4,
-    pub w: ScePspIVector4,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspIMatrix4Unaligned {
-    pub x: ScePspIVector4,
-    pub y: ScePspIVector4,
-    pub z: ScePspIVector4,
-    pub w: ScePspIVector4,
-}
-
-#[repr(C, align(16))]
-#[derive(Copy, Clone)]
-pub struct ScePspFMatrix4 {
-    pub x: ScePspFVector4,
-    pub y: ScePspFVector4,
-    pub z: ScePspFVector4,
-    pub w: ScePspFVector4,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct ScePspFMatrix4Unaligned {
-    pub x: ScePspFVector4,
-    pub y: ScePspFVector4,
-    pub z: ScePspFVector4,
-    pub w: ScePspFVector4,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union ScePspMatrix4 {
-    pub fm: ScePspFMatrix4,
-    pub im: ScePspIMatrix4,
-    pub fv: [ScePspFVector4; 4usize],
-    pub iv: [ScePspIVector4; 4usize],
-    pub v: [ScePspVector4; 4usize],
-    pub f: [[f32; 4usize]; 4usize],
-    pub i: [[i32; 4usize]; 4usize],
-}
diff --git a/src/psp/umd.rs b/src/psp/umd.rs
deleted file mode 100644
index 1fe24a2e05..0000000000
--- a/src/psp/umd.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-pub type UmdCallback = fn(unknown: i32, event: i32) -> i32;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UmdInfo {
-    pub size: u32,
-    pub type_: UmdType,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum UmdType {
-    Game = 0x10,
-    Video = 0x20,
-    Audio = 0x40,
-}
-
-pub const UMD_NOT_PRESENT: i32 = 0x01;
-pub const UMD_PRESENT: i32 = 0x02;
-pub const UMD_CHANGED: i32 = 0x04;
-pub const UMD_INITING: i32 = 0x08;
-pub const UMD_INITED: i32 = 0x10;
-pub const UMD_READY: i32 = 0x20;
-
-extern "C" {
-    pub fn sceUmdCheckMedium() -> i32;
-    pub fn sceUmdGetDiscInfo(info: *mut UmdInfo) -> i32;
-    pub fn sceUmdActivate(unit: i32, drive: *const u8) -> i32;
-    pub fn sceUmdDeactivate(unit: i32, drive: *const u8) -> i32;
-    pub fn sceUmdWaitDriveStat(state: i32) -> i32;
-    pub fn sceUmdWaitDriveStatWithTimer(
-        state: i32,
-        timeout: u32,
-    ) -> i32;
-    pub fn sceUmdWaitDriveStatCB(
-        state: i32,
-        timeout: u32,
-    ) -> i32;
-    pub fn sceUmdCancelWaitDriveStat() -> i32;
-    pub fn sceUmdGetDriveStat() -> i32;
-    pub fn sceUmdGetErrorStat() -> i32;
-    pub fn sceUmdRegisterUMDCallBack(cbid: i32) -> i32;
-    pub fn sceUmdUnRegisterUMDCallBack(cbid: i32) -> i32;
-    pub fn sceUmdReplacePermit() -> i32;
-    pub fn sceUmdReplaceProhibit() -> i32;
-}
diff --git a/src/psp/usb.rs b/src/psp/usb.rs
deleted file mode 100644
index 9632a04e25..0000000000
--- a/src/psp/usb.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-use super::c_void;
-use super::SceUid;
-
-pub const USB_CAM_PID: i32 = 0x282;
-pub const USB_BUS_DRIVER_NAME: &str = "USBBusDriver";
-pub const USB_CAM_DRIVER_NAME: &str = "USBCamDriver";
-pub const USB_CAM_MIC_DRIVER_NAME: &str = "USBCamMicDriver";
-pub const USB_STOR_DRIVER_NAME: &str = "USBStor_Driver";
-
-pub const ACTIVATED: i32 = 0x200;
-pub const CONNECTED: i32 = 0x020;
-pub const ESTABLISHED: i32 = 0x002;
-
-pub const USB_CAM_FLIP: i32 = 1;
-pub const USB_CAM_MIRROR: i32 = 0x100;
-
-extern "C" {
-    pub fn sceUsbStart(
-        driver_name: *const u8,
-        size: i32,
-        args: *mut c_void,
-    ) -> i32;
-    pub fn sceUsbStop(
-        driver_name: *const u8,
-        size: i32,
-        args: *mut c_void,
-    ) -> i32;
-    pub fn sceUsbActivate(pid: u32) -> i32;
-    pub fn sceUsbDeactivate(pid: u32) -> i32;
-    pub fn sceUsbGetState() -> i32;
-    pub fn sceUsbGetDrvState(driver_name: *const u8) -> i32;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UsbCamSetupStillParam {
-    pub size: i32,
-    pub resolution: UsbCamResolution,
-    pub jpeg_size: i32,
-    pub reverse_flags: i32,
-    pub delay: UsbCamDelay,
-    pub comp_level: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UsbCamSetupStillExParam {
-    pub size: i32,
-    pub unk: u32,
-    pub resolution: UsbCamResolutionEx,
-    pub jpeg_size: i32,
-    pub comp_level: i32,
-    pub unk2: u32,
-    pub unk3: u32,
-    pub flip: i32,
-    pub mirror: i32,
-    pub delay: UsbCamDelay,
-    pub unk4: [u32; 5usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UsbCamSetupVideoParam {
-    pub size: i32,
-    pub resolution: UsbCamResolution,
-    pub framerate: UsbCamFrameRate,
-    pub white_balance: UsbCamWb,
-    pub saturation: i32,
-    pub brightness: i32,
-    pub contrast: i32,
-    pub sharpness: i32,
-    pub effect_mode: UsbCamEffectMode,
-    pub frame_size: i32,
-    pub unk: u32,
-    pub evl_evel: UsbCamEvLevel,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UsbCamSetupVideoExParam {
-    pub size: i32,
-    pub unk: u32,
-    pub resolution: UsbCamResolutionEx,
-    pub framerate: UsbCamFrameRate,
-    pub unk2: u32,
-    pub unk3: u32,
-    pub white_balance: UsbCamWb,
-    pub saturation: i32,
-    pub brightness: i32,
-    pub contrast: i32,
-    pub sharpness: i32,
-    pub unk4: u32,
-    pub unk5: u32,
-    pub unk6: [u32; 3usize],
-    pub effect_mode: UsbCamEffectMode,
-    pub unk7: u32,
-    pub unk8: u32,
-    pub unk9: u32,
-    pub unk10: u32,
-    pub unk11: u32,
-    pub frame_size: i32,
-    pub unk12: u32,
-    pub ev_level: UsbCamEvLevel,
-}
-
-#[repr(i32)]
-#[derive(Copy, Clone)]
-pub enum UsbCamResolution {
-    Px160_120  = 0,
-    Px176_144  = 1,
-    Px320_240  = 2,
-    Px352_288  = 3,
-    Px640_480  = 4,
-    Px1024_768 = 5,
-    Px1280_960 = 6,
-    Px480_272  = 7,
-    Px360_272  = 8,
-}
-
-#[derive(Copy, Clone)]
-#[repr(i32)]
-pub enum UsbCamResolutionEx {
-    Px160_120  = 0,
-    Px176_144  = 1,
-    Px320_240  = 2,
-    Px352_288  = 3,
-    Px360_272  = 4,
-    Px480_272  = 5,
-    Px640_480  = 6,
-    Px1024_768 = 7,
-    Px1280_960 = 8,
-}
-
-#[repr(i32)]
-#[derive(Copy, Clone)]
-pub enum UsbCamDelay {
-    NoDelay = 0,
-    Delay10Sec = 1,
-    Delay20Sec = 2,
-    Delay30Sec = 3,
-}
-
-#[repr(i32)]
-#[derive(Copy, Clone)]
-pub enum UsbCamFrameRate {
-    Fps3_75 = 0,
-    Fps5 = 1,
-    Fps7_5 = 2,
-    Fps10 = 3,
-    Fps15 = 4,
-    Fps20 = 5,
-    Fps30 = 6,
-    Fps60 = 7,
-}
-
-#[repr(i32)]
-#[derive(Copy, Clone)]
-pub enum UsbCamWb {
-    Auto = 0,
-    Daylight = 1,
-    Fluorescent = 2,
-    Incadescent = 3,
-}
-
-#[repr(i32)]
-#[derive(Copy, Clone)]
-pub enum UsbCamEffectMode {
-    Normal = 0,
-    Negative = 1,
-    Blackwhite = 2,
-    Sepia = 3,
-    Blue = 4,
-    Red = 5,
-    Green = 6,
-}
-
-#[repr(i32)]
-#[derive(Copy, Clone)]
-pub enum UsbCamEvLevel {
-    Pos2_0 = 0,
-    Pos1_7 = 1,
-    Pos1_5 = 2,
-    Pos1_3 = 3,
-    Pos1_0 = 4,
-    Pos0_7 = 5,
-    Pos0_5 = 6,
-    Pos0_3 = 7,
-    Zero = 8,
-    Neg0_3,
-    Neg0_5,
-    Neg0_7,
-    Neg1_0,
-    Neg1_3,
-    Neg1_5,
-    Neg1_7,
-    Neg2_0,
-}
-
-extern "C" {
-    pub fn sceUsbCamSetupStill(param: *mut UsbCamSetupStillParam) -> i32;
-    pub fn sceUsbCamSetupStillEx(param: *mut UsbCamSetupStillExParam) -> i32;
-    pub fn sceUsbCamStillInputBlocking(buf: *mut u8, size: usize) -> i32;
-    pub fn sceUsbCamStillInput(buf: *mut u8, size: usize) -> i32;
-    pub fn sceUsbCamStillWaitInputEnd() -> i32;
-    pub fn sceUsbCamStillPollInputEnd() -> i32;
-    pub fn sceUsbCamStillCancelInput() -> i32;
-    pub fn sceUsbCamStillGetInputLength() -> i32;
-    pub fn sceUsbCamSetupVideo(
-        param: *mut UsbCamSetupVideoParam,
-        work_area: *mut c_void,
-        work_area_size: i32,
-    ) -> i32;
-    pub fn sceUsbCamSetupVideoEx(
-        param: *mut UsbCamSetupVideoExParam,
-        work_area: *mut c_void,
-        work_area_size: i32,
-    ) -> i32;
-    pub fn sceUsbCamStartVideo() -> i32;
-    pub fn sceUsbCamStopVideo() -> i32;
-    pub fn sceUsbCamReadVideoFrameBlocking(buf: *mut u8, size: usize) -> i32;
-    pub fn sceUsbCamReadVideoFrame(buf: *mut u8, size: usize) -> i32;
-    pub fn sceUsbCamWaitReadVideoFrameEnd() -> i32;
-    pub fn sceUsbCamPollReadVideoFrameEnd() -> i32;
-    pub fn sceUsbCamGetReadVideoFrameSize() -> i32;
-    pub fn sceUsbCamSetSaturation(saturation: i32) -> i32;
-    pub fn sceUsbCamSetBrightness(brightness: i32) -> i32;
-    pub fn sceUsbCamSetContrast(contrast: i32) -> i32;
-    pub fn sceUsbCamSetSharpness(sharpness: i32) -> i32;
-    pub fn sceUsbCamSetImageEffectMode(effect_mode: UsbCamEffectMode) -> i32;
-    pub fn sceUsbCamSetEvLevel(exposure_level: UsbCamEvLevel) -> i32;
-    pub fn sceUsbCamSetReverseMode(reverse_flags: i32) -> i32;
-    pub fn sceUsbCamSetZoom(zoom: i32) -> i32;
-    pub fn sceUsbCamGetSaturation(saturation: *mut i32) -> i32;
-    pub fn sceUsbCamGetBrightness(brightness: *mut i32) -> i32;
-    pub fn sceUsbCamGetContrast(contrast: *mut i32) -> i32;
-    pub fn sceUsbCamGetSharpness(sharpness: *mut i32) -> i32;
-    pub fn sceUsbCamGetImageEffectMode(
-        effect_mode: *mut UsbCamEffectMode,
-    ) -> i32;
-    pub fn sceUsbCamGetEvLevel(exposure_level: *mut UsbCamEvLevel) -> i32;
-    pub fn sceUsbCamGetReverseMode(
-        reverse_flags: *mut i32,
-    ) -> i32;
-    pub fn sceUsbCamGetZoom(zoom: *mut i32) -> i32;
-    pub fn sceUsbCamAutoImageReverseSW(on: i32) -> i32;
-    pub fn sceUsbCamGetAutoImageReverseState() -> i32;
-    pub fn sceUsbCamGetLensDirection() -> i32;
-}
-
-extern "C" {
-    pub fn sceUsbstorBootRegisterNotify(event_flag: SceUid) -> i32;
-    pub fn sceUsbstorBootUnregisterNotify(event_flag: u32) -> i32;
-    pub fn sceUsbstorBootSetCapacity(size: u32) -> i32;
-}
diff --git a/src/psp/utility.rs b/src/psp/utility.rs
deleted file mode 100644
index 19148e3665..0000000000
--- a/src/psp/utility.rs
+++ /dev/null
@@ -1,600 +0,0 @@
-use super::c_void;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilityDialogCommon {
-    pub size: u32,
-    pub language: SystemParamLanguage,
-    pub button_accept: UtilityDialogButtonAccept,
-    pub graphics_thread: i32,
-    pub access_thread: i32,
-    pub font_thread: i32,
-    pub sound_thread: i32,
-    pub result: i32,
-    pub reserved: [i32; 4usize],
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityMsgDialogMode {
-    Error,
-    Text,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityMsgDialogPressed {
-    Unknown1,
-    Yes,
-    No,
-    Back,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityDialogButtonAccept {
-    Circle,
-    Cross,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SceUtilityOskInputLanguage {
-    Default,
-    Japanese,
-    English,
-    French,
-    Spanish,
-    German,
-    Italian,
-    Dutch,
-    Portugese,
-    Russian,
-    Korean,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SceUtilityOskInputType {
-    All,
-    LatinDigit,
-    LatinSymbol,
-    LatinLowercase = 4,
-    LatinUppercase = 8,
-    JapaneseDigit = 0x100,
-    JapaneseSymbol = 0x200,
-    JapaneseLowercase = 0x400,
-    JapaneseUppercase = 0x800,
-    JapaneseHiragana = 0x1000,
-    JapaneseHalfWidthKatakana = 0x2000,
-    JapaneseKatakana = 0x4000,
-    JapaneseKanji = 0x8000,
-    RussianLowercase = 0x10000,
-    RussianUppercase = 0x20000,
-    Korean = 0x40000,
-    Url = 0x80000,
-}
-
-#[derive(Clone, Copy)]
-pub enum SceUtilityOskState {
-    None,
-    Initializing,
-    Initialized,
-    Visible,
-    Quit,
-    Finished,
-}
-
-#[derive(Clone, Copy)]
-pub enum SceUtilityOskResult {
-    Unchanged,
-    Cancelled,
-    Changed,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamLanguage {
-    Japanese,
-    English,
-    French,
-    Spanish,
-    German,
-    Italian,
-    Dutch,
-    Portugese,
-    Russian,
-    Korean,
-    ChineseTraditional,
-    ChineseSimplified,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamId {
-    StringNickname = 1,
-    AdhocChannel,
-    WlanPowerSave,
-    DateFormat,
-    TimeFormat,
-    Timezone,
-    DaylightSavings,
-    Language,
-    Unknown,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamAdhocChannel {
-    ChannelAutomatic = 0,
-    Channel1 = 1,
-    Channel6 = 6,
-    Channel11 = 11,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamWlanPowerSaveState {
-    Off,
-    On,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamDateFormat {
-    YYYYMMDD,
-    MMDDYYYY,
-    DDMMYYYY,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamTimeFormat {
-    Hour24,
-    Hour12,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum SystemParamDaylightSavings {
-    Std,
-    Dst,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum AvModule {
-    AvCodec,
-    SasCore,
-    Atrac3Plus,
-    MpegBase,
-    Mp3,
-    Vaudio,
-    Aac,
-    G729,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum Module {
-    NetCommon = 0x100,
-    NetAdhoc,
-    NetInet,
-    NetParseUri,
-    NetHttp,
-    NetSsl,
-
-    UsbPspCm = 0x200,
-    UsbMic,
-    UsbCam,
-    UsbGps,
-
-    AvCodec = 0x300,
-    AvSascore,
-    AvAtrac3Plus,
-    AvMpegBase,
-    AvMp3,
-    AvVaudio,
-    AvAac,
-    AvG729,
-
-    NpCommon = 0x400,
-    NpService,
-    NpMatching2,
-    NpDrm = 0x500,
-
-    Irda = 0x600,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum NetModule {
-    NetCommon = 1,
-    NetAdhoc,
-    NetInet,
-    NetParseUri,
-    NetHttp,
-    NetSsl,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UsbModule {
-    UsbPspCm = 1,
-    UsbAcc,
-    UsbMic,
-    UsbCam,
-    UsbGps,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum NetParam {
-    Name,
-    Ssid,
-    Secure,
-    WepKey,
-    IsStaticIp,
-    Ip,
-    NetMask,
-    Route,
-    ManualDns,
-    PrimaryDns,
-    SecondaryDns,
-    ProxyUser,
-    ProxyPass,
-    UseProxy,
-    ProxyServer,
-    ProxyPort,
-    Unknown1,
-    Unknown2,
-}
-
-#[derive(Copy, Clone)]
-pub enum UtilityNetconfAction {
-    ConnectAP,
-    DisplayStatus,
-    ConnectAdhoc,
-}
-
-pub const UTILITY_MSGDIALOG_ERROR: i32 = 0;
-pub const UTILITY_MSGDIALOG_TEXT: i32 = 1;
-pub const UTILITY_MSGDIALOG_YES_NO_BUTTONS: i32 = 0x10;
-pub const UTILITY_MSGDIALOG_DEFAULT_NO: i32 = 0x100;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilityMsgDialogParams {
-    pub base: UtilityDialogCommon,
-    pub unknown: i32,
-    pub mode: UtilityMsgDialogMode,
-    pub error_value: u32,
-    pub message: [u8; 512usize],
-    pub options: i32,
-    pub button_pressed: UtilityMsgDialogPressed,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilityNetconfAdhoc {
-    pub name: [u8; 8usize],
-    pub timeout: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilityNetconfData {
-    pub base: UtilityDialogCommon,
-    pub action: UtilityNetconfAction,
-    pub adhocparam: *mut UtilityNetconfAdhoc,
-    pub hotspot: i32,
-    pub hotspot_connected: i32,
-    pub wifisp: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union UtilityNetData {
-    pub as_uint: u32,
-    pub as_string: [u8; 128usize],
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum UtilitySavedataMode {
-    AutoLoad,
-    AutoSave,
-    Load,
-    Save,
-    ListLoad,
-    ListSave,
-    ListDelete,
-    Delete,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum UtilitySavedataFocus {
-    Unknown1,
-    FirstList,
-    LastList,
-    Latest,
-    Oldest,
-    Unknown2,
-    Unknown3,
-    FirstEmpty,
-    LastEmpty,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilitySavedataSFOParam {
-    pub title: [u8; 128usize],
-    pub savedata_title: [u8; 128usize],
-    pub detail: [u8; 1024usize],
-    pub parental_level: u8,
-    pub unknown: [u8; 3usize],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilitySavedataFileData {
-    pub buf: *mut c_void,
-    pub buf_size: usize,
-    pub size: usize,
-    pub unknown: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilitySavedataListSaveNewData {
-    pub icon0: UtilitySavedataFileData,
-    pub title: *mut u8,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceUtilitySavedataParam {
-    pub base: UtilityDialogCommon,
-    pub mode: UtilitySavedataMode,
-    pub unknown1: i32,
-    pub overwrite: i32,
-    pub game_name: [u8; 13usize],
-    pub reserved: [u8; 3usize],
-    pub save_name: [u8; 20usize],
-    pub save_name_list: *mut [u8; 20usize],
-    pub file_name: [u8; 13usize],
-    pub reserved1: [u8; 3usize],
-    pub data_buf: *mut c_void,
-    pub data_buf_size: usize,
-    pub data_size: usize,
-    pub sfo_param: UtilitySavedataSFOParam,
-    pub icon0_file_data: UtilitySavedataFileData,
-    pub icon1_file_data: UtilitySavedataFileData,
-    pub pic1_file_data: UtilitySavedataFileData,
-    pub snd0_file_data: UtilitySavedataFileData,
-    pub new_data: *mut UtilitySavedataListSaveNewData,
-    pub focus: UtilitySavedataFocus,
-    pub unknown2: [i32; 4usize],
-    pub key: [u8; 16],
-    pub unknown3: [u8; 20],
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum UtilityGameSharingMode {
-    Single = 1,
-    Multiple,
-}
-
-#[repr(u32)]
-#[derive(Copy, Clone)]
-pub enum UtilityGameSharingDataType {
-    File = 1,
-    Memory,
-}
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilityGameSharingParams {
-    pub base: UtilityDialogCommon,
-    pub unknown1: i32,
-    pub unknown2: i32,
-    pub name: [u8; 8usize],
-    pub unknown3: i32,
-    pub unknown4: i32,
-    pub unknown5: i32,
-    pub result: i32,
-    pub filepath: *mut u8,
-    pub mode: UtilityGameSharingMode,
-    pub datatype: UtilityGameSharingDataType,
-    pub data: *mut c_void,
-    pub datasize: u32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct UtilityHtmlViewerParam {
-    pub base: UtilityDialogCommon,
-    pub memaddr: *mut c_void,
-    pub memsize: u32,
-    pub unknown1: i32,
-    pub unknown2: i32,
-    pub initialurl: *mut u8,
-    pub numtabs: u32,
-    pub interfacemode: UtilityHtmlViewerInterfaceMode,
-    pub options: i32,
-    pub dldirname: *mut u8,
-    pub dlfilename: *mut u8,
-    pub uldirname: *mut u8,
-    pub ulfilename: *mut u8,
-    pub cookiemode: UtilityHtmlViewerCookieMode,
-    pub unknown3: u32,
-    pub homeurl: *mut u8,
-    pub textsize: UtilityHtmlViewerTextSize,
-    pub displaymode: UtilityHtmlViewerDisplayMode,
-    pub connectmode: UtilityHtmlViewerConnectMode,
-    pub disconnectmode: UtilityHtmlViewerDisconnectMode,
-    pub memused: u32,
-    pub unknown4: [i32; 10usize],
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityHtmlViewerInterfaceMode {
-    Full,
-    Limited,
-    None,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityHtmlViewerCookieMode {
-    Disabled = 0,
-    Enabled,
-    Confirm,
-    Default,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityHtmlViewerTextSize {
-    Large,
-    Normal,
-    Small,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityHtmlViewerDisplayMode {
-    Normal,
-    Fit,
-    SmartFit,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityHtmlViewerConnectMode {
-    Last,
-    ManualOnce,
-    ManualAll,
-}
-
-#[repr(u32)]
-#[derive(Clone, Copy)]
-pub enum UtilityHtmlViewerDisconnectMode {
-    Enable,
-    Disable,
-    Confirm,
-}
-
-pub const UTILITY_HTMLVIEWER_OPEN_SCE_START_PAGE: i32 = 0x000001;
-pub const UTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITS: i32 = 0x000002;
-pub const UTILITY_HTMLVIEWER_DISABLE_EXIT_DIALOG: i32 = 0x000004;
-pub const UTILITY_HTMLVIEWER_DISABLE_CURSOR: i32 = 0x000008;
-pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_COMPLETE_DIALOG: i32 = 0x000010;
-pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_START_DIALOG: i32 = 0x000020;
-pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_DESTINATION_DIALOG: i32 =
-    0x000040;
-pub const UTILITY_HTMLVIEWER_LOCK_DOWNLOAD_DESTINATION_DIALOG: i32 = 0x000080;
-pub const UTILITY_HTMLVIEWER_DISABLE_TAB_DISPLAY: i32 = 0x000100;
-pub const UTILITY_HTMLVIEWER_ENABLE_ANALOG_HOLD: i32 = 0x000200;
-pub const UTILITY_HTMLVIEWER_ENABLE_FLASH: i32 = 0x000400;
-pub const UTILITY_HTMLVIEWER_DISABLE_LRTRIGGER: i32 = 0x000800;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceUtilityOskData {
-    pub unk_00: i32,
-    pub unk_04: i32,
-    pub language: SceUtilityOskInputLanguage,
-    pub unk_12: i32,
-    pub inputtype: SceUtilityOskInputType,
-    pub lines: i32,
-    pub unk_24: i32,
-    pub desc: *mut u16,
-    pub intext: *mut u16,
-    pub outtextlength: i32,
-    pub outtext: *mut u16,
-    pub result: SceUtilityOskResult,
-    pub outtextlimit: i32,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SceUtilityOskParams {
-    pub base: UtilityDialogCommon,
-    pub datacount: i32,
-    pub data: *mut SceUtilityOskData,
-    pub state: SceUtilityOskState,
-    pub unk_60: i32,
-}
-
-extern "C" {
-    pub fn sceUtilityMsgDialogInitStart(
-        params: *mut UtilityMsgDialogParams,
-    ) -> i32;
-    pub fn sceUtilityMsgDialogShutdownStart();
-    pub fn sceUtilityMsgDialogGetStatus() -> i32;
-    pub fn sceUtilityMsgDialogUpdate(n: i32);
-    pub fn sceUtilityMsgDialogAbort() -> i32;
-    pub fn sceUtilityNetconfInitStart(data: *mut UtilityNetconfData) -> i32;
-    pub fn sceUtilityNetconfShutdownStart() -> i32;
-    pub fn sceUtilityNetconfUpdate(unknown: i32) -> i32;
-    pub fn sceUtilityNetconfGetStatus() -> i32;
-    pub fn sceUtilityCheckNetParam(id: i32) -> i32;
-    pub fn sceUtilityGetNetParam(
-        conf: i32,
-        param: NetParam,
-        data: *mut UtilityNetData,
-    ) -> i32;
-    pub fn sceUtilitySavedataInitStart(
-        params: *mut SceUtilitySavedataParam,
-    ) -> i32;
-    pub fn sceUtilitySavedataGetStatus() -> i32;
-    pub fn sceUtilitySavedataShutdownStart() -> i32;
-    pub fn sceUtilitySavedataUpdate(unknown: i32);
-    pub fn sceUtilityGameSharingInitStart(
-        params: *mut UtilityGameSharingParams,
-    ) -> i32;
-    pub fn sceUtilityGameSharingShutdownStart();
-    pub fn sceUtilityGameSharingGetStatus() -> i32;
-    pub fn sceUtilityGameSharingUpdate(n: i32);
-    pub fn sceUtilityHtmlViewerInitStart(
-        params: *mut UtilityHtmlViewerParam,
-    ) -> i32;
-    pub fn sceUtilityHtmlViewerShutdownStart() -> i32;
-    pub fn sceUtilityHtmlViewerUpdate(n: i32) -> i32;
-    pub fn sceUtilityHtmlViewerGetStatus() -> i32;
-    pub fn sceUtilitySetSystemParamInt(id: SystemParamId, value: i32) -> i32;
-    pub fn sceUtilitySetSystemParamString(
-        id: SystemParamId,
-        str: *const u8,
-    ) -> i32;
-    pub fn sceUtilityGetSystemParamInt(
-        id: SystemParamId,
-        value: *mut i32,
-    ) -> i32;
-    pub fn sceUtilityGetSystemParamString(
-        id: SystemParamId,
-        str: *mut u8,
-        len: i32,
-    ) -> i32;
-    pub fn sceUtilityOskInitStart(params: *mut SceUtilityOskParams) -> i32;
-    pub fn sceUtilityOskShutdownStart() -> i32;
-    pub fn sceUtilityOskUpdate(n: i32) -> i32;
-    pub fn sceUtilityOskGetStatus() -> i32;
-    pub fn sceUtilityLoadNetModule(module: NetModule) -> i32;
-    pub fn sceUtilityUnloadNetModule(module: NetModule) -> i32;
-    pub fn sceUtilityLoadAvModule(module: AvModule) -> i32;
-    pub fn sceUtilityUnloadAvModule(module: AvModule) -> i32;
-    pub fn sceUtilityLoadUsbModule(module: UsbModule) -> i32;
-    pub fn sceUtilityUnloadUsbModule(module: UsbModule) -> i32;
-    pub fn sceUtilityLoadModule(module: Module) -> i32;
-    pub fn sceUtilityUnloadModule(module: Module) -> i32;
-}
-
-extern "C" {
-    pub fn sceUtilityCreateNetParam(conf: i32) -> i32;
-    pub fn sceUtilitySetNetParam(param: NetParam, val: *const c_void) -> i32;
-    pub fn sceUtilityCopyNetParam(src: i32, dest: i32) -> i32;
-    pub fn sceUtilityDeleteNetParam(conf: i32) -> i32;
-}
diff --git a/src/psp/wlan.rs b/src/psp/wlan.rs
deleted file mode 100644
index 2fa7d283e1..0000000000
--- a/src/psp/wlan.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-extern "C" {
-    pub fn sceWlanDevIsPowerOn() -> i32;
-    pub fn sceWlanGetSwitchState() -> i32;
-    pub fn sceWlanGetEtherAddr(ether_addr: *mut u8) -> i32;
-}
-
-extern "C" {
-    pub fn sceWlanDevAttach() -> i32;
-    pub fn sceWlanDevDetach() -> i32;
-}