rust3ds
/
ctru-rs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Use bindgen for ctru_sys bindings

pull/10/head
Fenrir 8 years ago
parent
9ecf14ee08
commit
cf1f07558a
68 changed files with 45 additions and 5572 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      ctru-sys/Cargo.toml
  2. 36
      ctru-sys/build.rs
  3. 1
      ctru-sys/src/applets/mod.rs
  4. 258
      ctru-sys/src/applets/swkbd.rs
  5. 68
      ctru-sys/src/console.rs
  6. 14
      ctru-sys/src/env.rs
  7. 48
      ctru-sys/src/gfx.rs
  8. 27
      ctru-sys/src/gpu/gpu.rs
  9. 55
      ctru-sys/src/gpu/gx.rs
  10. 5
      ctru-sys/src/gpu/mod.rs
  11. 743
      ctru-sys/src/gpu/registers.rs
  12. 68
      ctru-sys/src/gpu/shaderProgram.rs
  13. 134
      ctru-sys/src/gpu/shbin.rs
  14. 9
      ctru-sys/src/ipc.rs
  15. 34
      ctru-sys/src/lib.rs
  16. 82
      ctru-sys/src/ndsp/channel.rs
  17. 2
      ctru-sys/src/ndsp/mod.rs
  18. 112
      ctru-sys/src/ndsp/ndsp.rs
  19. 47
      ctru-sys/src/os.rs
  20. 54
      ctru-sys/src/result.rs
  21. 64
      ctru-sys/src/romfs.rs
  22. 29
      ctru-sys/src/sdmc.rs
  23. 13
      ctru-sys/src/services/ac.rs
  24. 186
      ctru-sys/src/services/am.rs
  25. 18
      ctru-sys/src/services/ampxi.rs
  26. 241
      ctru-sys/src/services/apt.rs
  27. 392
      ctru-sys/src/services/cam.rs
  28. 19
      ctru-sys/src/services/cfgnor.rs
  29. 60
      ctru-sys/src/services/cfgu.rs
  30. 45
      ctru-sys/src/services/dsp.rs
  31. 547
      ctru-sys/src/services/fs.rs
  32. 107
      ctru-sys/src/services/gspgpu.rs
  33. 22
      ctru-sys/src/services/gsplcd.rs
  34. 119
      ctru-sys/src/services/hid.rs
  35. 126
      ctru-sys/src/services/httpc.rs
  36. 25
      ctru-sys/src/services/ir.rs
  37. 24
      ctru-sys/src/services/irrst.rs
  38. 47
      ctru-sys/src/services/mic.rs
  39. 31
      ctru-sys/src/services/mod.rs
  40. 0
      ctru-sys/src/services/mvd.rs
  41. 23
      ctru-sys/src/services/ndm.rs
  42. 52
      ctru-sys/src/services/news.rs
  43. 127
      ctru-sys/src/services/nfc.rs
  44. 17
      ctru-sys/src/services/ns.rs
  45. 19
      ctru-sys/src/services/pm.rs
  46. 8
      ctru-sys/src/services/pmtsym.rs
  47. 53
      ctru-sys/src/services/ps.rs
  48. 15
      ctru-sys/src/services/ptmsym.rs
  49. 15
      ctru-sys/src/services/ptmsysm.rs
  50. 16
      ctru-sys/src/services/ptmu.rs
  51. 50
      ctru-sys/src/services/pxidev.rs
  52. 42
      ctru-sys/src/services/qtm.rs
  53. 108
      ctru-sys/src/services/soc.rs
  54. 18
      ctru-sys/src/services/srvpm.rs
  55. 115
      ctru-sys/src/services/sslc.rs
  56. 6
      ctru-sys/src/services/uds.rs
  57. 184
      ctru-sys/src/services/y2r.rs
  58. 15
      ctru-sys/src/srv.rs
  59. 479
      ctru-sys/src/svc.rs
  60. 40
      ctru-sys/src/synchronization.rs
  61. 42
      ctru-sys/src/sys/inaddr.rs
  62. 92
      ctru-sys/src/sys/libc.rs
  63. 32
      ctru-sys/src/sys/lock.rs
  64. 3
      ctru-sys/src/sys/mod.rs
  65. 75
      ctru-sys/src/sys/socket.rs
  66. 19
      ctru-sys/src/thread.rs
  67. 27
      ctru-sys/src/types.rs
  68. 10
      ctru-sys/src/vram.rs

3
ctru-sys/Cargo.toml
Unescape View File

@ -1,8 +1,9 @@
[package] [package]
name = "ctru-sys" name = "ctru-sys"
version = "0.3.0" version = "0.4.0"
authors = ["Ronald Kinard <furyhunter600@gmail.com>"] authors = ["Ronald Kinard <furyhunter600@gmail.com>"]
license = "https://en.wikipedia.org/wiki/Zlib_License" license = "https://en.wikipedia.org/wiki/Zlib_License"
links = "ctru"
[dependencies.libc] [dependencies.libc]
version = "0.2" version = "0.2"

36
ctru-sys/build.rs
Unescape View File

@ -0,0 +1,36 @@
extern crate bindgen;
use std::env;
use std::path::PathBuf;
fn main() {
let devkitpro_path = PathBuf::from(env::var("DEVKITPRO").unwrap());
println!("cargo:rustc-link-search=native={}", devkitpro_path.join("libctru/lib").display());
println!("cargo:rustc-link-lib=static={}", match env::var("PROFILE").unwrap().as_str() {
"release" => "ctru",
"debug" => "ctrud",
_ => unreachable!(),
});
let bindings = bindgen::Builder::default()
.use_core()
.trust_clang_mangling(false)
.generate_comments(false)
.ctypes_prefix("libc")
.header(devkitpro_path.join("libctru/include/3ds.h").to_str().unwrap())
.hide_type("u8")
.hide_type("u16")
.hide_type("u32")
.hide_type("u64")
.clang_arg(format!("--sysroot={}/devkitARM/arm-none-eabi", devkitpro_path.display()))
.clang_arg(format!("-I{}/libctru/include", devkitpro_path.display()))
.generate()
.expect("Unable to generate bindings");
let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
bindings
.write_to_file(out_path.join("bindings.rs"))
.expect("Couldn't write bindings");
}

1
ctru-sys/src/applets/mod.rs
Unescape View File

@ -1 +0,0 @@
pub mod swkbd;

258
ctru-sys/src/applets/swkbd.rs
Unescape View File

@ -1,258 +0,0 @@
// automatically generated by rust-bindgen
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SwkbdType {
SWKBD_TYPE_NORMAL = 0,
SWKBD_TYPE_QWERTY = 1,
SWKBD_TYPE_NUMPAD = 2,
SWKBD_TYPE_WESTERN = 3,
}
pub const SWKBD_NOTBLANK_NOTEMPTY: SwkbdValidInput = SwkbdValidInput::SWKBD_NOTEMPTY_NOTBLANK;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SwkbdValidInput {
SWKBD_ANYTHING = 0,
SWKBD_NOTEMPTY = 1,
SWKBD_NOTEMPTY_NOTBLANK = 2,
SWKBD_NOTBLANK = 3,
SWKBD_FIXEDLEN = 4,
}
pub const SWKBD_BUTTON_CONFIRM: SwkbdButton = SwkbdButton::SWKBD_BUTTON_RIGHT;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SwkbdButton {
SWKBD_BUTTON_LEFT = 0,
SWKBD_BUTTON_MIDDLE = 1,
SWKBD_BUTTON_RIGHT = 2,
SWKBD_BUTTON_NONE = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SwkbdPasswordMode {
SWKBD_PASSWORD_NONE = 0,
SWKBD_PASSWORD_HIDE = 1,
SWKBD_PASSWORD_HIDE_DELAY = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
SWKBD_FILTER_DIGITS = 1,
SWKBD_FILTER_AT = 2,
SWKBD_FILTER_PERCENT = 4,
SWKBD_FILTER_BACKSLASH = 8,
SWKBD_FILTER_PROFANITY = 16,
SWKBD_FILTER_CALLBACK = 32,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed2 {
SWKBD_PARENTAL = 1,
SWKBD_DARKEN_TOP_SCREEN = 2,
SWKBD_PREDICTIVE_INPUT = 4,
SWKBD_MULTILINE = 8,
SWKBD_FIXED_WIDTH = 16,
SWKBD_ALLOW_HOME = 32,
SWKBD_ALLOW_RESET = 64,
SWKBD_ALLOW_POWER = 128,
SWKBD_DEFAULT_QWERTY = 512,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SwkbdCallbackResult {
SWKBD_CALLBACK_OK = 0,
SWKBD_CALLBACK_CLOSE = 1,
SWKBD_CALLBACK_CONTINUE = 2,
}
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum SwkbdResult {
SWKBD_NONE = -1,
SWKBD_INVALID_INPUT = -2,
SWKBD_OUTOFMEM = -3,
SWKBD_D0_CLICK = 0,
SWKBD_D1_CLICK0 = 1,
SWKBD_D1_CLICK1 = 2,
SWKBD_D2_CLICK0 = 3,
SWKBD_D2_CLICK1 = 4,
SWKBD_D2_CLICK2 = 5,
SWKBD_HOMEPRESSED = 10,
SWKBD_RESETPRESSED = 11,
SWKBD_POWERPRESSED = 12,
SWKBD_PARENTAL_OK = 20,
SWKBD_PARENTAL_FAIL = 21,
SWKBD_BANNED_INPUT = 30,
}
#[repr(C)]
#[derive(Copy)]
pub struct SwkbdDictWord {
pub reading: [u16; 41usize],
pub word: [u16; 41usize],
pub language: u8,
pub all_languages: u8,
}
impl ::core::clone::Clone for SwkbdDictWord {
fn clone(&self) -> Self {
*self
}
}
impl ::core::default::Default for SwkbdDictWord {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
pub type SwkbdCallbackFn =
::core::option::Option<unsafe extern "C" fn(user: *mut ::libc::c_void,
ppMessage: *mut *const u8,
text: *const u8,
textlen: usize)
-> SwkbdCallbackResult>;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SwkbdStatusData {
pub data: [u32; 17usize],
}
impl ::core::default::Default for SwkbdStatusData {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy)]
pub struct SwkbdLearningData {
pub data: [u32; 10523usize],
}
impl ::core::clone::Clone for SwkbdLearningData {
fn clone(&self) -> Self {
*self
}
}
impl ::core::default::Default for SwkbdLearningData {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SwkbdExtra {
pub initial_text: *const u8,
pub dict: *const SwkbdDictWord,
pub status_data: *mut SwkbdStatusData,
pub learning_data: *mut SwkbdLearningData,
pub callback: SwkbdCallbackFn,
pub callback_user: *mut ::libc::c_void,
}
impl ::core::default::Default for SwkbdExtra {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy)]
pub struct SwkbdState {
pub type_: i32,
pub num_buttons_m1: i32,
pub valid_input: i32,
pub password_mode: i32,
pub is_parental_screen: i32,
pub darken_top_screen: i32,
pub filter_flags: u32,
pub save_state_flags: u32,
pub max_text_len: u16,
pub dict_word_count: u16,
pub max_digits: u16,
pub button_text: [[u16; 17usize]; 3usize],
pub numpad_keys: [u16; 2usize],
pub hint_text: [u16; 65usize],
pub predictive_input: u8,
pub multiline: u8,
pub fixed_width: u8,
pub allow_home: u8,
pub allow_reset: u8,
pub allow_power: u8,
pub unknown: u8,
pub default_qwerty: u8,
pub button_submits_text: [u8; 4usize],
pub language: u16,
pub initial_text_offset: i32,
pub dict_offset: i32,
pub initial_status_offset: i32,
pub initial_learning_offset: i32,
pub shared_memory_size: usize,
pub version: u32,
pub result: SwkbdResult,
pub status_offset: i32,
pub learning_offset: i32,
pub text_offset: i32,
pub text_length: u16,
pub callback_result: i32,
pub callback_msg: [u16; 257usize],
pub skip_at_check: u8,
pub union: _bindgen_data_1_,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _bindgen_data_1_ {
pub reserved: [u8; 171usize],
pub extra: SwkbdExtra,
}
impl ::core::clone::Clone for SwkbdState {
fn clone(&self) -> Self {
*self
}
}
impl ::core::default::Default for SwkbdState {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
extern "C" {
pub fn swkbdInit(swkbd: *mut SwkbdState,
type_: SwkbdType,
numButtons: i32,
maxTextLength: i32);
pub fn swkbdSetFeatures(swkbd: *mut SwkbdState, features: u32);
pub fn swkbdSetHintText(swkbd: *mut SwkbdState, text: *const u8);
pub fn swkbdSetButton(swkbd: *mut SwkbdState,
button: SwkbdButton,
text: *const u8,
submit: u8);
pub fn swkbdSetInitialText(swkbd: *mut SwkbdState, text: *const u8);
pub fn swkbdSetDictWord(word: *mut SwkbdDictWord,
reading: *const u8,
text: *const u8);
pub fn swkbdSetDictionary(swkbd: *mut SwkbdState,
dict: *const SwkbdDictWord,
wordCount: i32);
pub fn swkbdSetStatusData(swkbd: *mut SwkbdState,
data: *mut SwkbdStatusData,
in_: u8,
out: u8);
pub fn swkbdSetLearningData(swkbd: *mut SwkbdState,
data: *mut SwkbdLearningData,
in_: u8,
out: u8);
pub fn swkbdSetFilterCallback(swkbd: *mut SwkbdState,
callback: SwkbdCallbackFn,
user: *mut ::libc::c_void);
pub fn swkbdInputText(swkbd: *mut SwkbdState,
buf: *mut u8,
bufsize: usize)
-> SwkbdButton;
}

68
ctru-sys/src/console.rs
Unescape View File

@ -1,68 +0,0 @@
use libc::c_void;
use super::gfx::*;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ConsoleFont {
pub gfx: *mut u8,
pub asciiOffset: u16,
pub numChars: u16,
}
pub type ConsolePrint = extern "C" fn(con: *mut c_void, c: i32) -> u8;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct PrintConsole {
pub font: ConsoleFont,
pub frameBuffer: *mut u16,
pub cursorX: i32,
pub cursorY: i32,
pub prevCursorX: i32,
pub prevCursorY: i32,
pub consoleWidth: i32,
pub consoleHeight: i32,
pub windowX: i32,
pub windowY: i32,
pub windowWidth: i32,
pub windowHeight: i32,
pub tabSize: i32,
pub fg: i32,
pub bg: i32,
pub flags: i32,
pub PrintChar: ConsolePrint,
pub consoleInitialised: u8,
}
pub const CONSOLE_COLOR_BOLD: i32 = 1;
pub const CONSOLE_COLOR_FAINT: i32 = 2;
pub const CONSOLE_ITALIC: i32 = 4;
pub const CONSOLE_UNDERLINE: i32 = 8;
pub const CONSOLE_BLINK_SLOW: i32 = 16;
pub const CONSOLE_BLINK_FAST: i32 = 32;
pub const CONSOLE_COLOR_REVERSE: i32 = 64;
pub const CONSOLE_CONCEAL: i32 = 128;
#[repr(C)]
pub enum debugDevice {
NULL = 0,
_3DMOO = 1,
CONSOLE = 2,
}
extern "C" {
pub fn consoleSetFont(console: *mut PrintConsole, font: *mut ConsoleFont) -> ();
pub fn consoleSetWindow(console: *mut PrintConsole,
x: i32,
y: i32,
width: i32,
height: i32)
-> ();
pub fn consoleGetDefault() -> *mut PrintConsole;
pub fn consoleSelect(console: *mut PrintConsole) -> *mut PrintConsole;
pub fn consoleInit(screen: gfxScreen_t, console: *mut PrintConsole) -> *mut PrintConsole;
pub fn consoleDebugInit(device: debugDevice) -> ();
pub fn consoleClear() -> ();
}

14
ctru-sys/src/env.rs
Unescape View File

@ -1,14 +0,0 @@
//TODO: There are a bunch of static inline functions that bindgen didn't pick up and idk how they work
use ::Handle;
#[derive(Clone, Copy)]
#[repr(C)]
pub enum Enum_Unnamed1 {
RUNFLAG_APTWORKAROUND = 1,
RUNFLAG_APTREINIT = 2,
}
extern "C" {
pub fn envGetHandle(name: *const u8) -> Handle;
}

48
ctru-sys/src/gfx.rs
Unescape View File

@ -1,48 +0,0 @@
use services::gspgpu::*;
#[inline]
pub fn RGB565(r: u32, g: u32, b: u32) -> u32 {
(((b)&0x1f)|(((g)&0x3f)<<5)|(((r)&0x1f)<<11))
}
#[inline]
pub fn RGB8_to_565(r: u32, g: u32, b: u32) -> u32 {
(((b)>>3)&0x1f)|((((g)>>2)&0x3f)<<5)|((((r)>>3)&0x1f)<<11)
}
#[repr(C)]
pub enum gfxScreen_t {
GFX_TOP = 0,
GFX_BOTTOM = 1
}
#[repr(C)]
pub enum gfx3dSide_t {
GFX_LEFT = 0,
GFX_RIGHT = 1
}
extern "C" {
pub static mut gfxTopLeftFramebuffers: [*mut u8; 2usize];
pub static mut gfxTopRightFramebuffers: [*mut u8; 2usize];
pub static mut gfxBottomFramebuffers: [*mut u8; 2usize];
pub fn gfxInitDefault();
pub fn gfxInit(topFormat: GSPGPU_FramebufferFormats,
bottomFormat: GSPGPU_FramebufferFormats, vrambuffers: u8);
pub fn gfxExit();
pub fn gfxSet3D(enable: u8);
pub fn gfxIs3D() -> u8;
pub fn gfxSetScreenFormat(screen: gfxScreen_t,
format: GSPGPU_FramebufferFormats);
pub fn gfxGetScreenFormat(screen: gfxScreen_t)
-> GSPGPU_FramebufferFormats;
pub fn gfxSetDoubleBuffering(screen: gfxScreen_t, doubleBuffering: u8);
pub fn gfxFlushBuffers();
pub fn gfxConfigScreen(scr: gfxScreen_t, immediate: u8);
pub fn gfxSwapBuffers();
pub fn gfxSwapBuffersGpu();
pub fn gfxGetFramebuffer(screen: gfxScreen_t, side: gfx3dSide_t,
width: *mut u16, height: *mut u16) -> *mut u8;
}

27
ctru-sys/src/gpu/gpu.rs
Unescape View File

@ -1,27 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub static mut gpuCmdBuf: *mut u32_;
pub static mut gpuCmdBufSize: u32_;
pub static mut gpuCmdBufOffset: u32_;
}
extern "C" {
pub fn GPUCMD_SetBuffer(adr: *mut u32_, size: u32_, offset: u32_);
pub fn GPUCMD_SetBufferOffset(offset: u32_);
pub fn GPUCMD_GetBuffer(adr: *mut *mut u32_, size: *mut u32_,
offset: *mut u32_);
pub fn GPUCMD_AddRawCommands(cmd: *const u32_, size: u32_);
pub fn GPUCMD_Run();
pub fn GPUCMD_FlushAndRun();
pub fn GPUCMD_Add(header: u32_, param: *const u32_, paramlength: u32_);
pub fn GPUCMD_Finalize();
pub fn f32tof16(f: f32) -> u32_;
pub fn f32tof20(f: f32) -> u32_;
pub fn f32tof24(f: f32) -> u32_;
pub fn f32tof31(f: f32) -> u32_;
}
use ::types::*;

55
ctru-sys/src/gpu/gx.rs
Unescape View File

@ -1,55 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum GX_TRANSFER_FORMAT {
GX_TRANSFER_FMT_RGBA8 = 0,
GX_TRANSFER_FMT_RGB8 = 1,
GX_TRANSFER_FMT_RGB565 = 2,
GX_TRANSFER_FMT_RGB5A1 = 3,
GX_TRANSFER_FMT_RGBA4 = 4,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum GX_TRANSFER_SCALE {
GX_TRANSFER_SCALE_NO = 0,
GX_TRANSFER_SCALE_X = 1,
GX_TRANSFER_SCALE_XY = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum GX_FILL_CONTROL {
GX_FILL_TRIGGER = 1,
GX_FILL_FINISHED = 2,
GX_FILL_16BIT_DEPTH = 0,
GX_FILL_24BIT_DEPTH = 256,
GX_FILL_32BIT_DEPTH = 512,
}
extern "C" {
pub static mut gxCmdBuf: *mut u32_;
}
extern "C" {
pub fn GX_RequestDma(src: *mut u32_, dst: *mut u32_, length: u32_)
-> Result;
pub fn GX_ProcessCommandList(buf0a: *mut u32_, buf0s: u32_, flags: u8_)
-> Result;
pub fn GX_MemoryFill(buf0a: *mut u32_, buf0v: u32_, buf0e: *mut u32_,
control0: u16_, buf1a: *mut u32_, buf1v: u32_,
buf1e: *mut u32_, control1: u16_) -> Result;
pub fn GX_DisplayTransfer(inadr: *mut u32_, indim: u32_,
outadr: *mut u32_, outdim: u32_, flags: u32_)
-> Result;
pub fn GX_TextureCopy(inadr: *mut u32_, indim: u32_, outadr: *mut u32_,
outdim: u32_, size: u32_, flags: u32_) -> Result;
pub fn GX_FlushCacheRegions(buf0a: *mut u32_, buf0s: u32_,
buf1a: *mut u32_, buf1s: u32_,
buf2a: *mut u32_, buf2s: u32_) -> Result;
}
use ::types::*;

5
ctru-sys/src/gpu/mod.rs
Unescape View File

@ -1,5 +0,0 @@
pub mod gpu;
pub mod gx;
pub mod registers;
pub mod shaderProgram;
pub mod shbin;

743
ctru-sys/src/gpu/registers.rs
Unescape View File

@ -1,743 +0,0 @@
//Miscellaneous registers (0x000-0x03F)
pub const GPUREG_0000: i32 = 0x0000;
pub const GPUREG_0001: i32 = 0x0001;
pub const GPUREG_0002: i32 = 0x0002;
pub const GPUREG_0003: i32 = 0x0003;
pub const GPUREG_0004: i32 = 0x0004;
pub const GPUREG_0005: i32 = 0x0005;
pub const GPUREG_0006: i32 = 0x0006;
pub const GPUREG_0007: i32 = 0x0007;
pub const GPUREG_0008: i32 = 0x0008;
pub const GPUREG_0009: i32 = 0x0009;
pub const GPUREG_000A: i32 = 0x000A;
pub const GPUREG_000B: i32 = 0x000B;
pub const GPUREG_000C: i32 = 0x000C;
pub const GPUREG_000D: i32 = 0x000D;
pub const GPUREG_000E: i32 = 0x000E;
pub const GPUREG_000F: i32 = 0x000F;
pub const GPUREG_FINALIZE: i32 = 0x0010;
pub const GPUREG_0011: i32 = 0x0011;
pub const GPUREG_0012: i32 = 0x0012;
pub const GPUREG_0013: i32 = 0x0013;
pub const GPUREG_0014: i32 = 0x0014;
pub const GPUREG_0015: i32 = 0x0015;
pub const GPUREG_0016: i32 = 0x0016;
pub const GPUREG_0017: i32 = 0x0017;
pub const GPUREG_0018: i32 = 0x0018;
pub const GPUREG_0019: i32 = 0x0019;
pub const GPUREG_001A: i32 = 0x001A;
pub const GPUREG_001B: i32 = 0x001B;
pub const GPUREG_001C: i32 = 0x001C;
pub const GPUREG_001D: i32 = 0x001D;
pub const GPUREG_001E: i32 = 0x001E;
pub const GPUREG_001F: i32 = 0x001F;
pub const GPUREG_0020: i32 = 0x0020;
pub const GPUREG_0021: i32 = 0x0021;
pub const GPUREG_0022: i32 = 0x0022;
pub const GPUREG_0023: i32 = 0x0023;
pub const GPUREG_0024: i32 = 0x0024;
pub const GPUREG_0025: i32 = 0x0025;
pub const GPUREG_0026: i32 = 0x0026;
pub const GPUREG_0027: i32 = 0x0027;
pub const GPUREG_0028: i32 = 0x0028;
pub const GPUREG_0029: i32 = 0x0029;
pub const GPUREG_002A: i32 = 0x002A;
pub const GPUREG_002B: i32 = 0x002B;
pub const GPUREG_002C: i32 = 0x002C;
pub const GPUREG_002D: i32 = 0x002D;
pub const GPUREG_002E: i32 = 0x002E;
pub const GPUREG_002F: i32 = 0x002F;
pub const GPUREG_0030: i32 = 0x0030;
pub const GPUREG_0031: i32 = 0x0031;
pub const GPUREG_0032: i32 = 0x0032;
pub const GPUREG_0033: i32 = 0x0033;
pub const GPUREG_0034: i32 = 0x0034;
pub const GPUREG_0035: i32 = 0x0035;
pub const GPUREG_0036: i32 = 0x0036;
pub const GPUREG_0037: i32 = 0x0037;
pub const GPUREG_0038: i32 = 0x0038;
pub const GPUREG_0039: i32 = 0x0039;
pub const GPUREG_003A: i32 = 0x003A;
pub const GPUREG_003B: i32 = 0x003B;
pub const GPUREG_003C: i32 = 0x003C;
pub const GPUREG_003D: i32 = 0x003D;
pub const GPUREG_003E: i32 = 0x003E;
pub const GPUREG_003F: i32 = 0x003F;
//Rasterizer registers (0x040-0x07F)
pub const GPUREG_FACECULLING_CONFIG: i32 = 0x0040;
pub const GPUREG_0041: i32 = 0x0041;
pub const GPUREG_0042: i32 = 0x0042;
pub const GPUREG_0043: i32 = 0x0043;
pub const GPUREG_0044: i32 = 0x0044;
pub const GPUREG_0045: i32 = 0x0045;
pub const GPUREG_0046: i32 = 0x0046;
pub const GPUREG_0047: i32 = 0x0047;
pub const GPUREG_0048: i32 = 0x0048;
pub const GPUREG_0049: i32 = 0x0049;
pub const GPUREG_004A: i32 = 0x004A;
pub const GPUREG_004B: i32 = 0x004B;
pub const GPUREG_004C: i32 = 0x004C;
pub const GPUREG_DEPTHMAP_SCALE: i32 = 0x004D;
pub const GPUREG_DEPTHMAP_OFFSET: i32 = 0x004E;
pub const GPUREG_SH_OUTMAP_TOTAL: i32 = 0x004F;
pub const GPUREG_SH_OUTMAP_O0: i32 = 0x0050;
pub const GPUREG_SH_OUTMAP_O1: i32 = 0x0051;
pub const GPUREG_SH_OUTMAP_O2: i32 = 0x0052;
pub const GPUREG_SH_OUTMAP_O3: i32 = 0x0053;
pub const GPUREG_SH_OUTMAP_O4: i32 = 0x0054;
pub const GPUREG_SH_OUTMAP_O5: i32 = 0x0055;
pub const GPUREG_SH_OUTMAP_O6: i32 = 0x0056;
pub const GPUREG_0057: i32 = 0x0057;
pub const GPUREG_0058: i32 = 0x0058;
pub const GPUREG_0059: i32 = 0x0059;
pub const GPUREG_005A: i32 = 0x005A;
pub const GPUREG_005B: i32 = 0x005B;
pub const GPUREG_005C: i32 = 0x005C;
pub const GPUREG_005D: i32 = 0x005D;
pub const GPUREG_005E: i32 = 0x005E;
pub const GPUREG_005F: i32 = 0x005F;
pub const GPUREG_0060: i32 = 0x0060;
pub const GPUREG_0061: i32 = 0x0061;
pub const GPUREG_0062: i32 = 0x0062;
pub const GPUREG_0063: i32 = 0x0063;
pub const GPUREG_0064: i32 = 0x0064;
pub const GPUREG_SCISSORTEST_MODE: i32 = 0x0065;
pub const GPUREG_SCISSORTEST_POS: i32 = 0x0066;
pub const GPUREG_SCISSORTEST_DIM: i32 = 0x0067;
pub const GPUREG_0068: i32 = 0x0068;
pub const GPUREG_0069: i32 = 0x0069;
pub const GPUREG_006A: i32 = 0x006A;
pub const GPUREG_006B: i32 = 0x006B;
pub const GPUREG_006C: i32 = 0x006C;
pub const GPUREG_006D: i32 = 0x006D;
pub const GPUREG_006E: i32 = 0x006E;
pub const GPUREG_006F: i32 = 0x006F;
pub const GPUREG_0070: i32 = 0x0070;
pub const GPUREG_0071: i32 = 0x0071;
pub const GPUREG_0072: i32 = 0x0072;
pub const GPUREG_0073: i32 = 0x0073;
pub const GPUREG_0074: i32 = 0x0074;
pub const GPUREG_0075: i32 = 0x0075;
pub const GPUREG_0076: i32 = 0x0076;
pub const GPUREG_0077: i32 = 0x0077;
pub const GPUREG_0078: i32 = 0x0078;
pub const GPUREG_0079: i32 = 0x0079;
pub const GPUREG_007A: i32 = 0x007A;
pub const GPUREG_007B: i32 = 0x007B;
pub const GPUREG_007C: i32 = 0x007C;
pub const GPUREG_007D: i32 = 0x007D;
pub const GPUREG_007E: i32 = 0x007E;
pub const GPUREG_007F: i32 = 0x007F;
//Texturing registers (0x080-0x0FF)
pub const GPUREG_TEXUNITS_CONFIG: i32 = 0x0080;
pub const GPUREG_0081: i32 = 0x0081;
pub const GPUREG_TEXUNIT0_DIM: i32 = 0x0082;
pub const GPUREG_TEXUNIT0_PARAM: i32 = 0x0083;
pub const GPUREG_0084: i32 = 0x0084;
pub const GPUREG_TEXUNIT0_LOC: i32 = 0x0085;
pub const GPUREG_0086: i32 = 0x0086;
pub const GPUREG_0087: i32 = 0x0087;
pub const GPUREG_0088: i32 = 0x0088;
pub const GPUREG_0089: i32 = 0x0089;
pub const GPUREG_008A: i32 = 0x008A;
pub const GPUREG_008B: i32 = 0x008B;
pub const GPUREG_008C: i32 = 0x008C;
pub const GPUREG_008D: i32 = 0x008D;
pub const GPUREG_TEXUNIT0_TYPE: i32 = 0x008E;
pub const GPUREG_008F: i32 = 0x008F;
pub const GPUREG_0090: i32 = 0x0090;
pub const GPUREG_0091: i32 = 0x0091;
pub const GPUREG_TEXUNIT1_DIM: i32 = 0x0092;
pub const GPUREG_TEXUNIT1_PARAM: i32 = 0x0093;
pub const GPUREG_0094: i32 = 0x0094;
pub const GPUREG_TEXUNIT1_LOC: i32 = 0x0095;
pub const GPUREG_TEXUNIT1_TYPE: i32 = 0x0096;
pub const GPUREG_0097: i32 = 0x0097;
pub const GPUREG_0098: i32 = 0x0098;
pub const GPUREG_0099: i32 = 0x0099;
pub const GPUREG_TEXUNIT2_DIM: i32 = 0x009A;
pub const GPUREG_TEXUNIT2_PARAM: i32 = 0x009B;
pub const GPUREG_009C: i32 = 0x009C;
pub const GPUREG_TEXUNIT2_LOC: i32 = 0x009D;
pub const GPUREG_TEXUNIT2_TYPE: i32 = 0x009E;
pub const GPUREG_009F: i32 = 0x009F;
pub const GPUREG_00A0: i32 = 0x00A0;
pub const GPUREG_00A1: i32 = 0x00A1;
pub const GPUREG_00A2: i32 = 0x00A2;
pub const GPUREG_00A3: i32 = 0x00A3;
pub const GPUREG_00A4: i32 = 0x00A4;
pub const GPUREG_00A5: i32 = 0x00A5;
pub const GPUREG_00A6: i32 = 0x00A6;
pub const GPUREG_00A7: i32 = 0x00A7;
pub const GPUREG_00A8: i32 = 0x00A8;
pub const GPUREG_00A9: i32 = 0x00A9;
pub const GPUREG_00AA: i32 = 0x00AA;
pub const GPUREG_00AB: i32 = 0x00AB;
pub const GPUREG_00AC: i32 = 0x00AC;
pub const GPUREG_00AD: i32 = 0x00AD;
pub const GPUREG_00AE: i32 = 0x00AE;
pub const GPUREG_00AF: i32 = 0x00AF;
pub const GPUREG_00B0: i32 = 0x00B0;
pub const GPUREG_00B1: i32 = 0x00B1;
pub const GPUREG_00B2: i32 = 0x00B2;
pub const GPUREG_00B3: i32 = 0x00B3;
pub const GPUREG_00B4: i32 = 0x00B4;
pub const GPUREG_00B5: i32 = 0x00B5;
pub const GPUREG_00B6: i32 = 0x00B6;
pub const GPUREG_00B7: i32 = 0x00B7;
pub const GPUREG_00B8: i32 = 0x00B8;
pub const GPUREG_00B9: i32 = 0x00B9;
pub const GPUREG_00BA: i32 = 0x00BA;
pub const GPUREG_00BB: i32 = 0x00BB;
pub const GPUREG_00BC: i32 = 0x00BC;
pub const GPUREG_00BD: i32 = 0x00BD;
pub const GPUREG_00BE: i32 = 0x00BE;
pub const GPUREG_00BF: i32 = 0x00BF;
pub const GPUREG_TEXENV0_CONFIG0: i32 = 0x00C0;
pub const GPUREG_TEXENV0_CONFIG1: i32 = 0x00C1;
pub const GPUREG_TEXENV0_CONFIG2: i32 = 0x00C2;
pub const GPUREG_TEXENV0_CONFIG3: i32 = 0x00C3;
pub const GPUREG_TEXENV0_CONFIG4: i32 = 0x00C4;
pub const GPUREG_00C5: i32 = 0x00C5;
pub const GPUREG_00C6: i32 = 0x00C6;
pub const GPUREG_00C7: i32 = 0x00C7;
pub const GPUREG_TEXENV1_CONFIG0: i32 = 0x00C8;
pub const GPUREG_TEXENV1_CONFIG1: i32 = 0x00C9;
pub const GPUREG_TEXENV1_CONFIG2: i32 = 0x00CA;
pub const GPUREG_TEXENV1_CONFIG3: i32 = 0x00CB;
pub const GPUREG_TEXENV1_CONFIG4: i32 = 0x00CC;
pub const GPUREG_00CD: i32 = 0x00CD;
pub const GPUREG_00CE: i32 = 0x00CE;
pub const GPUREG_00CF: i32 = 0x00CF;
pub const GPUREG_TEXENV2_CONFIG0: i32 = 0x00D0;
pub const GPUREG_TEXENV2_CONFIG1: i32 = 0x00D1;
pub const GPUREG_TEXENV2_CONFIG2: i32 = 0x00D2;
pub const GPUREG_TEXENV2_CONFIG3: i32 = 0x00D3;
pub const GPUREG_TEXENV2_CONFIG4: i32 = 0x00D4;
pub const GPUREG_00D5: i32 = 0x00D5;
pub const GPUREG_00D6: i32 = 0x00D6;
pub const GPUREG_00D7: i32 = 0x00D7;
pub const GPUREG_TEXENV3_CONFIG0: i32 = 0x00D8;
pub const GPUREG_TEXENV3_CONFIG1: i32 = 0x00D9;
pub const GPUREG_TEXENV3_CONFIG2: i32 = 0x00DA;
pub const GPUREG_TEXENV3_CONFIG3: i32 = 0x00DB;
pub const GPUREG_TEXENV3_CONFIG4: i32 = 0x00DC;
pub const GPUREG_00DD: i32 = 0x00DD;
pub const GPUREG_00DE: i32 = 0x00DE;
pub const GPUREG_00DF: i32 = 0x00DF;
pub const GPUREG_00E0: i32 = 0x00E0;
pub const GPUREG_00E1: i32 = 0x00E1;
pub const GPUREG_00E2: i32 = 0x00E2;
pub const GPUREG_00E3: i32 = 0x00E3;
pub const GPUREG_00E4: i32 = 0x00E4;
pub const GPUREG_00E5: i32 = 0x00E5;
pub const GPUREG_00E6: i32 = 0x00E6;
pub const GPUREG_00E7: i32 = 0x00E7;
pub const GPUREG_00E8: i32 = 0x00E8;
pub const GPUREG_00E9: i32 = 0x00E9;
pub const GPUREG_00EA: i32 = 0x00EA;
pub const GPUREG_00EB: i32 = 0x00EB;
pub const GPUREG_00EC: i32 = 0x00EC;
pub const GPUREG_00ED: i32 = 0x00ED;
pub const GPUREG_00EE: i32 = 0x00EE;
pub const GPUREG_00EF: i32 = 0x00EF;
pub const GPUREG_TEXENV4_CONFIG0: i32 = 0x00F0;
pub const GPUREG_TEXENV4_CONFIG1: i32 = 0x00F1;
pub const GPUREG_TEXENV4_CONFIG2: i32 = 0x00F2;
pub const GPUREG_TEXENV4_CONFIG3: i32 = 0x00F3;
pub const GPUREG_TEXENV4_CONFIG4: i32 = 0x00F4;
pub const GPUREG_00F5: i32 = 0x00F5;
pub const GPUREG_00F6: i32 = 0x00F6;
pub const GPUREG_00F7: i32 = 0x00F7;
pub const GPUREG_TEXENV5_CONFIG0: i32 = 0x00F8;
pub const GPUREG_TEXENV5_CONFIG1: i32 = 0x00F9;
pub const GPUREG_TEXENV5_CONFIG2: i32 = 0x00FA;
pub const GPUREG_TEXENV5_CONFIG3: i32 = 0x00FB;
pub const GPUREG_TEXENV5_CONFIG4: i32 = 0x00FC;
pub const GPUREG_00FD: i32 = 0x00FD;
pub const GPUREG_00FE: i32 = 0x00FE;
pub const GPUREG_00FF: i32 = 0x00FF;
//Framebuffer registers (0x100-0x13F)
pub const GPUREG_COLOROUTPUT_CONFIG: i32 = 0x0100;
pub const GPUREG_BLEND_CONFIG: i32 = 0x0101;
pub const GPUREG_COLORLOGICOP_CONFIG: i32 = 0x0102;
pub const GPUREG_BLEND_COLOR: i32 = 0x0103;
pub const GPUREG_ALPHATEST_CONFIG: i32 = 0x0104;
pub const GPUREG_STENCILTEST_CONFIG: i32 = 0x0105;
pub const GPUREG_STENCILOP_CONFIG: i32 = 0x0106;
pub const GPUREG_DEPTHTEST_CONFIG: i32 = 0x0107;
pub const GPUREG_0108: i32 = 0x0108;
pub const GPUREG_0109: i32 = 0x0109;
pub const GPUREG_010A: i32 = 0x010A;
pub const GPUREG_010B: i32 = 0x010B;
pub const GPUREG_010C: i32 = 0x010C;
pub const GPUREG_010D: i32 = 0x010D;
pub const GPUREG_010E: i32 = 0x010E;
pub const GPUREG_010F: i32 = 0x010F;
pub const GPUREG_0110: i32 = 0x0110;
pub const GPUREG_0111: i32 = 0x0111;
pub const GPUREG_0112: i32 = 0x0112;
pub const GPUREG_0113: i32 = 0x0113;
pub const GPUREG_0114: i32 = 0x0114;
pub const GPUREG_0115: i32 = 0x0115;
pub const GPUREG_DEPTHBUFFER_FORMAT: i32 = 0x0116;
pub const GPUREG_COLORBUFFER_FORMAT: i32 = 0x0117;
pub const GPUREG_0118: i32 = 0x0118;
pub const GPUREG_0119: i32 = 0x0119;
pub const GPUREG_011A: i32 = 0x011A;
pub const GPUREG_011B: i32 = 0x011B;
pub const GPUREG_DEPTHBUFFER_LOC: i32 = 0x011C;
pub const GPUREG_COLORBUFFER_LOC: i32 = 0x011D;
pub const GPUREG_OUTBUFFER_DIM: i32 = 0x011E;
pub const GPUREG_011F: i32 = 0x011F;
pub const GPUREG_0120: i32 = 0x0120;
pub const GPUREG_0121: i32 = 0x0121;
pub const GPUREG_0122: i32 = 0x0122;
pub const GPUREG_0123: i32 = 0x0123;
pub const GPUREG_0124: i32 = 0x0124;
pub const GPUREG_0125: i32 = 0x0125;
pub const GPUREG_0126: i32 = 0x0126;
pub const GPUREG_0127: i32 = 0x0127;
pub const GPUREG_0128: i32 = 0x0128;
pub const GPUREG_0129: i32 = 0x0129;
pub const GPUREG_012A: i32 = 0x012A;
pub const GPUREG_012B: i32 = 0x012B;
pub const GPUREG_012C: i32 = 0x012C;
pub const GPUREG_012D: i32 = 0x012D;
pub const GPUREG_012E: i32 = 0x012E;
pub const GPUREG_012F: i32 = 0x012F;
pub const GPUREG_0130: i32 = 0x0130;
pub const GPUREG_0131: i32 = 0x0131;
pub const GPUREG_0132: i32 = 0x0132;
pub const GPUREG_0133: i32 = 0x0133;
pub const GPUREG_0134: i32 = 0x0134;
pub const GPUREG_0135: i32 = 0x0135;
pub const GPUREG_0136: i32 = 0x0136;
pub const GPUREG_0137: i32 = 0x0137;
pub const GPUREG_0138: i32 = 0x0138;
pub const GPUREG_0139: i32 = 0x0139;
pub const GPUREG_013A: i32 = 0x013A;
pub const GPUREG_013B: i32 = 0x013B;
pub const GPUREG_013C: i32 = 0x013C;
pub const GPUREG_013D: i32 = 0x013D;
pub const GPUREG_013E: i32 = 0x013E;
pub const GPUREG_013F: i32 = 0x013F;
//Fragment lighting registers (0x140-0x1FF)
pub const GPUREG_0140: i32 = 0x0140;
pub const GPUREG_0141: i32 = 0x0141;
pub const GPUREG_0142: i32 = 0x0142;
pub const GPUREG_0143: i32 = 0x0143;
pub const GPUREG_0144: i32 = 0x0144;
pub const GPUREG_0145: i32 = 0x0145;
pub const GPUREG_0146: i32 = 0x0146;
pub const GPUREG_0147: i32 = 0x0147;
pub const GPUREG_0148: i32 = 0x0148;
pub const GPUREG_0149: i32 = 0x0149;
pub const GPUREG_014A: i32 = 0x014A;
pub const GPUREG_014B: i32 = 0x014B;
pub const GPUREG_014C: i32 = 0x014C;
pub const GPUREG_014D: i32 = 0x014D;
pub const GPUREG_014E: i32 = 0x014E;
pub const GPUREG_014F: i32 = 0x014F;
pub const GPUREG_0150: i32 = 0x0150;
pub const GPUREG_0151: i32 = 0x0151;
pub const GPUREG_0152: i32 = 0x0152;
pub const GPUREG_0153: i32 = 0x0153;
pub const GPUREG_0154: i32 = 0x0154;
pub const GPUREG_0155: i32 = 0x0155;
pub const GPUREG_0156: i32 = 0x0156;
pub const GPUREG_0157: i32 = 0x0157;
pub const GPUREG_0158: i32 = 0x0158;
pub const GPUREG_0159: i32 = 0x0159;
pub const GPUREG_015A: i32 = 0x015A;
pub const GPUREG_015B: i32 = 0x015B;
pub const GPUREG_015C: i32 = 0x015C;
pub const GPUREG_015D: i32 = 0x015D;
pub const GPUREG_015E: i32 = 0x015E;
pub const GPUREG_015F: i32 = 0x015F;
pub const GPUREG_0160: i32 = 0x0160;
pub const GPUREG_0161: i32 = 0x0161;
pub const GPUREG_0162: i32 = 0x0162;
pub const GPUREG_0163: i32 = 0x0163;
pub const GPUREG_0164: i32 = 0x0164;
pub const GPUREG_0165: i32 = 0x0165;
pub const GPUREG_0166: i32 = 0x0166;
pub const GPUREG_0167: i32 = 0x0167;
pub const GPUREG_0168: i32 = 0x0168;
pub const GPUREG_0169: i32 = 0x0169;
pub const GPUREG_016A: i32 = 0x016A;
pub const GPUREG_016B: i32 = 0x016B;
pub const GPUREG_016C: i32 = 0x016C;
pub const GPUREG_016D: i32 = 0x016D;
pub const GPUREG_016E: i32 = 0x016E;
pub const GPUREG_016F: i32 = 0x016F;
pub const GPUREG_0170: i32 = 0x0170;
pub const GPUREG_0171: i32 = 0x0171;
pub const GPUREG_0172: i32 = 0x0172;
pub const GPUREG_0173: i32 = 0x0173;
pub const GPUREG_0174: i32 = 0x0174;
pub const GPUREG_0175: i32 = 0x0175;
pub const GPUREG_0176: i32 = 0x0176;
pub const GPUREG_0177: i32 = 0x0177;
pub const GPUREG_0178: i32 = 0x0178;
pub const GPUREG_0179: i32 = 0x0179;
pub const GPUREG_017A: i32 = 0x017A;
pub const GPUREG_017B: i32 = 0x017B;
pub const GPUREG_017C: i32 = 0x017C;
pub const GPUREG_017D: i32 = 0x017D;
pub const GPUREG_017E: i32 = 0x017E;
pub const GPUREG_017F: i32 = 0x017F;
pub const GPUREG_0180: i32 = 0x0180;
pub const GPUREG_0181: i32 = 0x0181;
pub const GPUREG_0182: i32 = 0x0182;
pub const GPUREG_0183: i32 = 0x0183;
pub const GPUREG_0184: i32 = 0x0184;
pub const GPUREG_0185: i32 = 0x0185;
pub const GPUREG_0186: i32 = 0x0186;
pub const GPUREG_0187: i32 = 0x0187;
pub const GPUREG_0188: i32 = 0x0188;
pub const GPUREG_0189: i32 = 0x0189;
pub const GPUREG_018A: i32 = 0x018A;
pub const GPUREG_018B: i32 = 0x018B;
pub const GPUREG_018C: i32 = 0x018C;
pub const GPUREG_018D: i32 = 0x018D;
pub const GPUREG_018E: i32 = 0x018E;
pub const GPUREG_018F: i32 = 0x018F;
pub const GPUREG_0190: i32 = 0x0190;
pub const GPUREG_0191: i32 = 0x0191;
pub const GPUREG_0192: i32 = 0x0192;
pub const GPUREG_0193: i32 = 0x0193;
pub const GPUREG_0194: i32 = 0x0194;
pub const GPUREG_0195: i32 = 0x0195;
pub const GPUREG_0196: i32 = 0x0196;
pub const GPUREG_0197: i32 = 0x0197;
pub const GPUREG_0198: i32 = 0x0198;
pub const GPUREG_0199: i32 = 0x0199;
pub const GPUREG_019A: i32 = 0x019A;
pub const GPUREG_019B: i32 = 0x019B;
pub const GPUREG_019C: i32 = 0x019C;
pub const GPUREG_019D: i32 = 0x019D;
pub const GPUREG_019E: i32 = 0x019E;
pub const GPUREG_019F: i32 = 0x019F;
pub const GPUREG_01A0: i32 = 0x01A0;
pub const GPUREG_01A1: i32 = 0x01A1;
pub const GPUREG_01A2: i32 = 0x01A2;
pub const GPUREG_01A3: i32 = 0x01A3;
pub const GPUREG_01A4: i32 = 0x01A4;
pub const GPUREG_01A5: i32 = 0x01A5;
pub const GPUREG_01A6: i32 = 0x01A6;
pub const GPUREG_01A7: i32 = 0x01A7;
pub const GPUREG_01A8: i32 = 0x01A8;
pub const GPUREG_01A9: i32 = 0x01A9;
pub const GPUREG_01AA: i32 = 0x01AA;
pub const GPUREG_01AB: i32 = 0x01AB;
pub const GPUREG_01AC: i32 = 0x01AC;
pub const GPUREG_01AD: i32 = 0x01AD;
pub const GPUREG_01AE: i32 = 0x01AE;
pub const GPUREG_01AF: i32 = 0x01AF;
pub const GPUREG_01B0: i32 = 0x01B0;
pub const GPUREG_01B1: i32 = 0x01B1;
pub const GPUREG_01B2: i32 = 0x01B2;
pub const GPUREG_01B3: i32 = 0x01B3;
pub const GPUREG_01B4: i32 = 0x01B4;
pub const GPUREG_01B5: i32 = 0x01B5;
pub const GPUREG_01B6: i32 = 0x01B6;
pub const GPUREG_01B7: i32 = 0x01B7;
pub const GPUREG_01B8: i32 = 0x01B8;
pub const GPUREG_01B9: i32 = 0x01B9;
pub const GPUREG_01BA: i32 = 0x01BA;
pub const GPUREG_01BB: i32 = 0x01BB;
pub const GPUREG_01BC: i32 = 0x01BC;
pub const GPUREG_01BD: i32 = 0x01BD;
pub const GPUREG_01BE: i32 = 0x01BE;
pub const GPUREG_01BF: i32 = 0x01BF;
pub const GPUREG_01C0: i32 = 0x01C0;
pub const GPUREG_01C1: i32 = 0x01C1;
pub const GPUREG_01C2: i32 = 0x01C2;
pub const GPUREG_01C3: i32 = 0x01C3;
pub const GPUREG_01C4: i32 = 0x01C4;
pub const GPUREG_01C5: i32 = 0x01C5;
pub const GPUREG_01C6: i32 = 0x01C6;
pub const GPUREG_01C7: i32 = 0x01C7;
pub const GPUREG_01C8: i32 = 0x01C8;
pub const GPUREG_01C9: i32 = 0x01C9;
pub const GPUREG_01CA: i32 = 0x01CA;
pub const GPUREG_01CB: i32 = 0x01CB;
pub const GPUREG_01CC: i32 = 0x01CC;
pub const GPUREG_01CD: i32 = 0x01CD;
pub const GPUREG_01CE: i32 = 0x01CE;
pub const GPUREG_01CF: i32 = 0x01CF;
pub const GPUREG_01D0: i32 = 0x01D0;
pub const GPUREG_01D1: i32 = 0x01D1;
pub const GPUREG_01D2: i32 = 0x01D2;
pub const GPUREG_01D3: i32 = 0x01D3;
pub const GPUREG_01D4: i32 = 0x01D4;
pub const GPUREG_01D5: i32 = 0x01D5;
pub const GPUREG_01D6: i32 = 0x01D6;
pub const GPUREG_01D7: i32 = 0x01D7;
pub const GPUREG_01D8: i32 = 0x01D8;
pub const GPUREG_01D9: i32 = 0x01D9;
pub const GPUREG_01DA: i32 = 0x01DA;
pub const GPUREG_01DB: i32 = 0x01DB;
pub const GPUREG_01DC: i32 = 0x01DC;
pub const GPUREG_01DD: i32 = 0x01DD;
pub const GPUREG_01DE: i32 = 0x01DE;
pub const GPUREG_01DF: i32 = 0x01DF;
pub const GPUREG_01E0: i32 = 0x01E0;
pub const GPUREG_01E1: i32 = 0x01E1;
pub const GPUREG_01E2: i32 = 0x01E2;
pub const GPUREG_01E3: i32 = 0x01E3;
pub const GPUREG_01E4: i32 = 0x01E4;
pub const GPUREG_01E5: i32 = 0x01E5;
pub const GPUREG_01E6: i32 = 0x01E6;
pub const GPUREG_01E7: i32 = 0x01E7;
pub const GPUREG_01E8: i32 = 0x01E8;
pub const GPUREG_01E9: i32 = 0x01E9;
pub const GPUREG_01EA: i32 = 0x01EA;
pub const GPUREG_01EB: i32 = 0x01EB;
pub const GPUREG_01EC: i32 = 0x01EC;
pub const GPUREG_01ED: i32 = 0x01ED;
pub const GPUREG_01EE: i32 = 0x01EE;
pub const GPUREG_01EF: i32 = 0x01EF;
pub const GPUREG_01F0: i32 = 0x01F0;
pub const GPUREG_01F1: i32 = 0x01F1;
pub const GPUREG_01F2: i32 = 0x01F2;
pub const GPUREG_01F3: i32 = 0x01F3;
pub const GPUREG_01F4: i32 = 0x01F4;
pub const GPUREG_01F5: i32 = 0x01F5;
pub const GPUREG_01F6: i32 = 0x01F6;
pub const GPUREG_01F7: i32 = 0x01F7;
pub const GPUREG_01F8: i32 = 0x01F8;
pub const GPUREG_01F9: i32 = 0x01F9;
pub const GPUREG_01FA: i32 = 0x01FA;
pub const GPUREG_01FB: i32 = 0x01FB;
pub const GPUREG_01FC: i32 = 0x01FC;
pub const GPUREG_01FD: i32 = 0x01FD;
pub const GPUREG_01FE: i32 = 0x01FE;
pub const GPUREG_01FF: i32 = 0x01FF;
//Geometry pipeline registers (0x200-0x27F)
pub const GPUREG_ATTRIBBUFFERS_LOC: i32 = 0x0200;
pub const GPUREG_ATTRIBBUFFERS_FORMAT_LOW: i32 = 0x0201;
pub const GPUREG_ATTRIBBUFFERS_FORMAT_HIGH: i32 = 0x0202;
pub const GPUREG_ATTRIBBUFFER0_CONFIG0: i32 = 0x0203;
pub const GPUREG_ATTRIBBUFFER0_CONFIG1: i32 = 0x0204;
pub const GPUREG_ATTRIBBUFFER0_CONFIG2: i32 = 0x0205;
pub const GPUREG_ATTRIBBUFFER1_CONFIG0: i32 = 0x0206;
pub const GPUREG_ATTRIBBUFFER1_CONFIG1: i32 = 0x0207;
pub const GPUREG_ATTRIBBUFFER1_CONFIG2: i32 = 0x0208;
pub const GPUREG_ATTRIBBUFFER2_CONFIG0: i32 = 0x0209;
pub const GPUREG_ATTRIBBUFFER2_CONFIG1: i32 = 0x020A;
pub const GPUREG_ATTRIBBUFFER2_CONFIG2: i32 = 0x020B;
pub const GPUREG_ATTRIBBUFFER3_CONFIG0: i32 = 0x020C;
pub const GPUREG_ATTRIBBUFFER3_CONFIG1: i32 = 0x020D;
pub const GPUREG_ATTRIBBUFFER3_CONFIG2: i32 = 0x020E;
pub const GPUREG_ATTRIBBUFFER4_CONFIG0: i32 = 0x020F;
pub const GPUREG_ATTRIBBUFFER4_CONFIG1: i32 = 0x0210;
pub const GPUREG_ATTRIBBUFFER4_CONFIG2: i32 = 0x0211;
pub const GPUREG_ATTRIBBUFFER5_CONFIG0: i32 = 0x0212;
pub const GPUREG_ATTRIBBUFFER5_CONFIG1: i32 = 0x0213;
pub const GPUREG_ATTRIBBUFFER5_CONFIG2: i32 = 0x0214;
pub const GPUREG_ATTRIBBUFFER6_CONFIG0: i32 = 0x0215;
pub const GPUREG_ATTRIBBUFFER6_CONFIG1: i32 = 0x0216;
pub const GPUREG_ATTRIBBUFFER6_CONFIG2: i32 = 0x0217;
pub const GPUREG_ATTRIBBUFFER7_CONFIG0: i32 = 0x0218;
pub const GPUREG_ATTRIBBUFFER7_CONFIG1: i32 = 0x0219;
pub const GPUREG_ATTRIBBUFFER7_CONFIG2: i32 = 0x021A;
pub const GPUREG_ATTRIBBUFFER8_CONFIG0: i32 = 0x021B;
pub const GPUREG_ATTRIBBUFFER8_CONFIG1: i32 = 0x021C;
pub const GPUREG_ATTRIBBUFFER8_CONFIG2: i32 = 0x021D;
pub const GPUREG_ATTRIBBUFFER9_CONFIG0: i32 = 0x021E;
pub const GPUREG_ATTRIBBUFFER9_CONFIG1: i32 = 0x021F;
pub const GPUREG_ATTRIBBUFFER9_CONFIG2: i32 = 0x0220;
pub const GPUREG_ATTRIBBUFFERA_CONFIG0: i32 = 0x0221;
pub const GPUREG_ATTRIBBUFFERA_CONFIG1: i32 = 0x0222;
pub const GPUREG_ATTRIBBUFFERA_CONFIG2: i32 = 0x0223;
pub const GPUREG_ATTRIBBUFFERB_CONFIG0: i32 = 0x0224;
pub const GPUREG_ATTRIBBUFFERB_CONFIG1: i32 = 0x0225;
pub const GPUREG_ATTRIBBUFFERB_CONFIG2: i32 = 0x0226;
pub const GPUREG_INDEXBUFFER_CONFIG: i32 = 0x0227;
pub const GPUREG_NUMVERTICES: i32 = 0x0228;
pub const GPUREG_GEOSTAGE_CONFIG: i32 = 0x0229;
pub const GPUREG_022A: i32 = 0x022A;
pub const GPUREG_022B: i32 = 0x022B;
pub const GPUREG_022C: i32 = 0x022C;
pub const GPUREG_022D: i32 = 0x022D;
pub const GPUREG_DRAWARRAYS: i32 = 0x022E;
pub const GPUREG_DRAWELEMENTS: i32 = 0x022F;
pub const GPUREG_0230: i32 = 0x0230;
pub const GPUREG_0231: i32 = 0x0231;
pub const GPUREG_0232: i32 = 0x0232;
pub const GPUREG_0233: i32 = 0x0233;
pub const GPUREG_0234: i32 = 0x0234;
pub const GPUREG_0235: i32 = 0x0235;
pub const GPUREG_0236: i32 = 0x0236;
pub const GPUREG_0237: i32 = 0x0237;
pub const GPUREG_0238: i32 = 0x0238;
pub const GPUREG_0239: i32 = 0x0239;
pub const GPUREG_023A: i32 = 0x023A;
pub const GPUREG_023B: i32 = 0x023B;
pub const GPUREG_023C: i32 = 0x023C;
pub const GPUREG_023D: i32 = 0x023D;
pub const GPUREG_023E: i32 = 0x023E;
pub const GPUREG_023F: i32 = 0x023F;
pub const GPUREG_0240: i32 = 0x0240;
pub const GPUREG_0241: i32 = 0x0241;
pub const GPUREG_0242: i32 = 0x0242;
pub const GPUREG_0243: i32 = 0x0243;
pub const GPUREG_0244: i32 = 0x0244;
pub const GPUREG_0245: i32 = 0x0245;
pub const GPUREG_0246: i32 = 0x0246;
pub const GPUREG_0247: i32 = 0x0247;
pub const GPUREG_0248: i32 = 0x0248;
pub const GPUREG_0249: i32 = 0x0249;
pub const GPUREG_024A: i32 = 0x024A;
pub const GPUREG_024B: i32 = 0x024B;
pub const GPUREG_024C: i32 = 0x024C;
pub const GPUREG_024D: i32 = 0x024D;
pub const GPUREG_024E: i32 = 0x024E;
pub const GPUREG_024F: i32 = 0x024F;
pub const GPUREG_0250: i32 = 0x0250;
pub const GPUREG_0251: i32 = 0x0251;
pub const GPUREG_0252: i32 = 0x0252;
pub const GPUREG_0253: i32 = 0x0253;
pub const GPUREG_0254: i32 = 0x0254;
pub const GPUREG_0255: i32 = 0x0255;
pub const GPUREG_0256: i32 = 0x0256;
pub const GPUREG_0257: i32 = 0x0257;
pub const GPUREG_0258: i32 = 0x0258;
pub const GPUREG_0259: i32 = 0x0259;
pub const GPUREG_025A: i32 = 0x025A;
pub const GPUREG_025B: i32 = 0x025B;
pub const GPUREG_025C: i32 = 0x025C;
pub const GPUREG_025D: i32 = 0x025D;
pub const GPUREG_PRIMITIVE_CONFIG: i32 = 0x025E;
pub const GPUREG_025F: i32 = 0x025F;
pub const GPUREG_0260: i32 = 0x0260;
pub const GPUREG_0261: i32 = 0x0261;
pub const GPUREG_0262: i32 = 0x0262;
pub const GPUREG_0263: i32 = 0x0263;
pub const GPUREG_0264: i32 = 0x0264;
pub const GPUREG_0265: i32 = 0x0265;
pub const GPUREG_0266: i32 = 0x0266;
pub const GPUREG_0267: i32 = 0x0267;
pub const GPUREG_0268: i32 = 0x0268;
pub const GPUREG_0269: i32 = 0x0269;
pub const GPUREG_026A: i32 = 0x026A;
pub const GPUREG_026B: i32 = 0x026B;
pub const GPUREG_026C: i32 = 0x026C;
pub const GPUREG_026D: i32 = 0x026D;
pub const GPUREG_026E: i32 = 0x026E;
pub const GPUREG_026F: i32 = 0x026F;
pub const GPUREG_0270: i32 = 0x0270;
pub const GPUREG_0271: i32 = 0x0271;
pub const GPUREG_0272: i32 = 0x0272;
pub const GPUREG_0273: i32 = 0x0273;
pub const GPUREG_0274: i32 = 0x0274;
pub const GPUREG_0275: i32 = 0x0275;
pub const GPUREG_0276: i32 = 0x0276;
pub const GPUREG_0277: i32 = 0x0277;
pub const GPUREG_0278: i32 = 0x0278;
pub const GPUREG_0279: i32 = 0x0279;
pub const GPUREG_027A: i32 = 0x027A;
pub const GPUREG_027B: i32 = 0x027B;
pub const GPUREG_027C: i32 = 0x027C;
pub const GPUREG_027D: i32 = 0x027D;
pub const GPUREG_027E: i32 = 0x027E;
pub const GPUREG_027F: i32 = 0x027F;
//Geometry shader registers (0x280-0x2AF)
pub const GPUREG_GSH_BOOLUNIFORM: i32 = 0x0280;
pub const GPUREG_GSH_INTUNIFORM_I0: i32 = 0x0281;
pub const GPUREG_GSH_INTUNIFORM_I1: i32 = 0x0282;
pub const GPUREG_GSH_INTUNIFORM_I2: i32 = 0x0283;
pub const GPUREG_GSH_INTUNIFORM_I3: i32 = 0x0284;
pub const GPUREG_0285: i32 = 0x0285;
pub const GPUREG_0286: i32 = 0x0286;
pub const GPUREG_0287: i32 = 0x0287;
pub const GPUREG_0288: i32 = 0x0288;
pub const GPUREG_GSH_INPUTBUFFER_CONFIG: i32 = 0x0289;
pub const GPUREG_GSH_ENTRYPOINT: i32 = 0x028A;
pub const GPUREG_GSH_ATTRIBUTES_PERMUTATION_LOW: i32 = 0x028B;
pub const GPUREG_GSH_ATTRIBUTES_PERMUTATION_HIGH: i32 = 0x028C;
pub const GPUREG_GSH_OUTMAP_MASK: i32 = 0x028D;
pub const GPUREG_028E: i32 = 0x028E;
pub const GPUREG_GSH_CODETRANSFER_END: i32 = 0x028F;
pub const GPUREG_GSH_FLOATUNIFORM_CONFIG: i32 = 0x0290;
pub const GPUREG_GSH_FLOATUNIFORM_DATA: i32 = 0x0291;
pub const GPUREG_0299: i32 = 0x0299;
pub const GPUREG_029A: i32 = 0x029A;
pub const GPUREG_GSH_CODETRANSFER_CONFIG: i32 = 0x029B;
pub const GPUREG_GSH_CODETRANSFER_DATA: i32 = 0x029C;
pub const GPUREG_02A4: i32 = 0x02A4;
pub const GPUREG_GSH_OPDESCS_CONFIG: i32 = 0x02A5;
pub const GPUREG_GSH_OPDESCS_DATA: i32 = 0x02A6;
pub const GPUREG_02AE: i32 = 0x02AE;
pub const GPUREG_02AF: i32 = 0x02AF;
//Vertex shader registers (0x2B0-0x2DF)
pub const GPUREG_VSH_BOOLUNIFORM: i32 = 0x02B0;
pub const GPUREG_VSH_INTUNIFORM_I0: i32 = 0x02B1;
pub const GPUREG_VSH_INTUNIFORM_I1: i32 = 0x02B2;
pub const GPUREG_VSH_INTUNIFORM_I2: i32 = 0x02B3;
pub const GPUREG_VSH_INTUNIFORM_I3: i32 = 0x02B4;
pub const GPUREG_02B5: i32 = 0x02B5;
pub const GPUREG_02B6: i32 = 0x02B6;
pub const GPUREG_02B7: i32 = 0x02B7;
pub const GPUREG_02B8: i32 = 0x02B8;
pub const GPUREG_VSH_INPUTBUFFER_CONFIG: i32 = 0x02B9;
pub const GPUREG_VSH_ENTRYPOINT: i32 = 0x02BA;
pub const GPUREG_VSH_ATTRIBUTES_PERMUTATION_LOW: i32 = 0x02BB;
pub const GPUREG_VSH_ATTRIBUTES_PERMUTATION_HIGH: i32 = 0x02BC;
pub const GPUREG_VSH_OUTMAP_MASK: i32 = 0x02BD;
pub const GPUREG_02BE: i32 = 0x02BE;
pub const GPUREG_VSH_CODETRANSFER_END: i32 = 0x02BF;
pub const GPUREG_VSH_FLOATUNIFORM_CONFIG: i32 = 0x02C0;
pub const GPUREG_VSH_FLOATUNIFORM_DATA: i32 = 0x02C1;
pub const GPUREG_02C9: i32 = 0x02C9;
pub const GPUREG_02CA: i32 = 0x02CA;
pub const GPUREG_VSH_CODETRANSFER_CONFIG: i32 = 0x02CB;
pub const GPUREG_VSH_CODETRANSFER_DATA: i32 = 0x02CC;
pub const GPUREG_02D4: i32 = 0x02D4;
pub const GPUREG_VSH_OPDESCS_CONFIG: i32 = 0x02D5;
pub const GPUREG_VSH_OPDESCS_DATA: i32 = 0x02D6;
pub const GPUREG_02DE: i32 = 0x02DE;
pub const GPUREG_02DF: i32 = 0x02DF;
//Unknown registers (0x2E0-0x2FF)
pub const GPUREG_02E0: i32 = 0x02E0;
pub const GPUREG_02E1: i32 = 0x02E1;
pub const GPUREG_02E2: i32 = 0x02E2;
pub const GPUREG_02E3: i32 = 0x02E3;
pub const GPUREG_02E4: i32 = 0x02E4;
pub const GPUREG_02E5: i32 = 0x02E5;
pub const GPUREG_02E6: i32 = 0x02E6;
pub const GPUREG_02E7: i32 = 0x02E7;
pub const GPUREG_02E8: i32 = 0x02E8;
pub const GPUREG_02E9: i32 = 0x02E9;
pub const GPUREG_02EA: i32 = 0x02EA;
pub const GPUREG_02EB: i32 = 0x02EB;
pub const GPUREG_02EC: i32 = 0x02EC;
pub const GPUREG_02ED: i32 = 0x02ED;
pub const GPUREG_02EE: i32 = 0x02EE;
pub const GPUREG_02EF: i32 = 0x02EF;
pub const GPUREG_02F0: i32 = 0x02F0;
pub const GPUREG_02F1: i32 = 0x02F1;
pub const GPUREG_02F2: i32 = 0x02F2;
pub const GPUREG_02F3: i32 = 0x02F3;
pub const GPUREG_02F4: i32 = 0x02F4;
pub const GPUREG_02F5: i32 = 0x02F5;
pub const GPUREG_02F6: i32 = 0x02F6;
pub const GPUREG_02F7: i32 = 0x02F7;
pub const GPUREG_02F8: i32 = 0x02F8;
pub const GPUREG_02F9: i32 = 0x02F9;
pub const GPUREG_02FA: i32 = 0x02FA;
pub const GPUREG_02FB: i32 = 0x02FB;
pub const GPUREG_02FC: i32 = 0x02FC;
pub const GPUREG_02FD: i32 = 0x02FD;
pub const GPUREG_02FE: i32 = 0x02FE;
pub const GPUREG_02FF: i32 = 0x02FF;

68
ctru-sys/src/gpu/shaderProgram.rs
Unescape View File

@ -1,68 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct float24Uniform_s {
pub id: u32_,
pub data: [u32_; 3usize],
}
impl ::core::default::Default for float24Uniform_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct shaderInstance_s {
pub dvle: *mut DVLE_s,
pub boolUniforms: u16_,
pub boolUniformMask: u16_,
pub intUniforms: [u32_; 4usize],
pub float24Uniforms: *mut float24Uniform_s,
pub intUniformMask: u8_,
pub numFloat24Uniforms: u8_,
}
impl ::core::default::Default for shaderInstance_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct shaderProgram_s {
pub vertexShader: *mut shaderInstance_s,
pub geometryShader: *mut shaderInstance_s,
pub geoShaderInputPermutation: [u32_; 2usize],
pub geoShaderInputStride: u8_,
}
impl ::core::default::Default for shaderProgram_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn shaderInstanceInit(si: *mut shaderInstance_s, dvle: *mut DVLE_s)
-> Result;
pub fn shaderInstanceFree(si: *mut shaderInstance_s) -> Result;
pub fn shaderInstanceSetBool(si: *mut shaderInstance_s, id: ::libc::c_int,
value: u8) -> Result;
pub fn shaderInstanceGetBool(si: *mut shaderInstance_s, id: ::libc::c_int,
value: *mut u8) -> Result;
pub fn shaderInstanceGetUniformLocation(si: *mut shaderInstance_s,
name: *const ::libc::c_char)
-> s8;
pub fn shaderProgramInit(sp: *mut shaderProgram_s) -> Result;
pub fn shaderProgramFree(sp: *mut shaderProgram_s) -> Result;
pub fn shaderProgramSetVsh(sp: *mut shaderProgram_s, dvle: *mut DVLE_s)
-> Result;
pub fn shaderProgramSetGsh(sp: *mut shaderProgram_s, dvle: *mut DVLE_s,
stride: u8_) -> Result;
pub fn shaderProgramSetGshInputPermutation(sp: *mut shaderProgram_s,
permutation: u64_) -> Result;
pub fn shaderProgramConfigure(sp: *mut shaderProgram_s, sendVshCode: u8,
sendGshCode: u8) -> Result;
pub fn shaderProgramUse(sp: *mut shaderProgram_s) -> Result;
}
use ::types::*;
use super::shbin::*;

134
ctru-sys/src/gpu/shbin.rs
Unescape View File

@ -1,134 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DVLE_type { VERTEX_SHDR = 0, GEOMETRY_SHDR = 1, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DVLE_constantType {
DVLE_CONST_BOOL = 0,
DVLE_CONST_u8 = 1,
DVLE_CONST_FLOAT24 = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DVLE_outputAttribute_t {
RESULT_POSITION = 0,
RESULT_NORMALQUAT = 1,
RESULT_COLOR = 2,
RESULT_TEXCOORD0 = 3,
RESULT_TEXCOORD0W = 4,
RESULT_TEXCOORD1 = 5,
RESULT_TEXCOORD2 = 6,
RESULT_VIEW = 8,
RESULT_DUMMY = 9,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DVLE_geoShaderMode {
GSH_POINT = 0,
GSH_VARIABLE_PRIM = 1,
GSH_FIXED_PRIM = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DVLP_s {
pub codeSize: u32_,
pub codeData: *mut u32_,
pub opdescSize: u32_,
pub opcdescData: *mut u32_,
}
impl ::core::default::Default for DVLP_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DVLE_constEntry_s {
pub type_: u16_,
pub id: u16_,
pub data: [u32_; 4usize],
}
impl ::core::default::Default for DVLE_constEntry_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DVLE_outEntry_s {
pub type_: u16_,
pub regID: u16_,
pub mask: u8_,
pub unk: [u8_; 3usize],
}
impl ::core::default::Default for DVLE_outEntry_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DVLE_uniformEntry_s {
pub symbolOffset: u32_,
pub startReg: u16_,
pub endReg: u16_,
}
impl ::core::default::Default for DVLE_uniformEntry_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DVLE_s {
pub type_: DVLE_type,
pub mergeOutmaps: u8,
pub gshMode: DVLE_geoShaderMode,
pub gshFixedVtxStart: u8_,
pub gshVariableVtxNum: u8_,
pub gshFixedVtxNum: u8_,
pub dvlp: *mut DVLP_s,
pub mainOffset: u32_,
pub endmainOffset: u32_,
pub constTableSize: u32_,
pub constTableData: *mut DVLE_constEntry_s,
pub outTableSize: u32_,
pub outTableData: *mut DVLE_outEntry_s,
pub uniformTableSize: u32_,
pub uniformTableData: *mut DVLE_uniformEntry_s,
pub symbolTableData: *mut ::libc::c_char,
pub outmapMask: u8_,
pub outmapData: [u32_; 8usize],
pub outmapMode: u32_,
pub outmapClock: u32_,
}
impl ::core::default::Default for DVLE_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DVLB_s {
pub numDVLE: u32_,
pub DVLP: DVLP_s,
pub DVLE: *mut DVLE_s,
}
impl ::core::default::Default for DVLB_s {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn DVLB_ParseFile(shbinData: *mut u32_, shbinSize: u32_)
-> *mut DVLB_s;
pub fn DVLB_Free(dvlb: *mut DVLB_s);
pub fn DVLE_GetUniformRegister(dvle: *mut DVLE_s,
name: *const ::libc::c_char) -> s8;
pub fn DVLE_GenerateOutmap(dvle: *mut DVLE_s);
}
use ::types::*;

9
ctru-sys/src/ipc.rs
Unescape View File

@ -1,9 +0,0 @@
//TODO: Implement static inline functions
#[derive(Clone, Copy)]
#[repr(C)]
pub enum IPC_BufferRights {
IPC_BUFFER_R = 2,
IPC_BUFFER_W = 4,
IPC_BUFFER_RW = 6,
}

34
ctru-sys/src/lib.rs
Unescape View File

@ -1,32 +1,12 @@
/* #![allow(non_upper_case_globals)]
* C bindings generation: #![allow(non_camel_case_types)]
* bindgen --match=file.h --use-core --ctypes-prefix=libc -- --sysroot=$DEVKITARM/arm-none-eabi -I$CTRULIB/include $CTRULIB/include/3ds.h #![allow(non_snake_case)]
*
*/
#![no_std] #![feature(const_fn)]
#![allow(non_camel_case_types, non_snake_case, overflowing_literals)]
#![feature(untagged_unions)] #![feature(untagged_unions)]
extern crate libc; #![no_std]
pub mod applets; extern crate libc;
pub mod console;
pub mod env;
pub mod gfx;
pub mod gpu;
pub mod ipc;
pub mod ndsp;
pub mod os;
pub mod romfs;
pub mod sdmc;
pub mod services;
pub mod svc;
pub mod srv;
pub mod sys;
pub mod synchronization;
pub mod thread;
pub mod types;
pub use self::sys::*; include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
pub use self::types::*;

82
ctru-sys/src/ndsp/channel.rs
Unescape View File

@ -1,82 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
use ::types::*;
use super::ndsp::ndspWaveBuf;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
NDSP_ENCODING_PCM8 = 0,
NDSP_ENCODING_PCM16 = 1,
NDSP_ENCODING_ADPCM = 2,
}
pub const NDSP_FORMAT_PCM8: Enum_Unnamed2 =
Enum_Unnamed2::NDSP_FORMAT_MONO_PCM8;
pub const NDSP_FORMAT_PCM16: Enum_Unnamed2 =
Enum_Unnamed2::NDSP_FORMAT_MONO_PCM16;
pub const NDSP_FORMAT_ADPCM: Enum_Unnamed2 =
Enum_Unnamed2::NDSP_FORMAT_MONO_ADPCM;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed2 {
NDSP_FORMAT_MONO_PCM8 = 1,
NDSP_FORMAT_MONO_PCM16 = 5,
NDSP_FORMAT_MONO_ADPCM = 9,
NDSP_FORMAT_STEREO_PCM8 = 2,
NDSP_FORMAT_STEREO_PCM16 = 6,
NDSP_FRONT_BYPASS = 16,
NDSP_3D_SURROUND_PREPROCESSED = 64,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ndspInterpType {
NDSP_INTERP_POLYPHASE = 0,
NDSP_INTERP_LINEAR = 1,
NDSP_INTERP_NONE = 2,
}
extern "C" {
pub fn ndspChnReset(id: ::libc::c_int);
pub fn ndspChnInitParams(id: ::libc::c_int);
pub fn ndspChnIsPlaying(id: ::libc::c_int) -> u8;
pub fn ndspChnGetSamplePos(id: ::libc::c_int) -> u32_;
pub fn ndspChnGetWaveBufSeq(id: ::libc::c_int) -> u16_;
pub fn ndspChnIsPaused(id: ::libc::c_int) -> u8;
pub fn ndspChnSetPaused(id: ::libc::c_int, paused: u8);
pub fn ndspChnSetFormat(id: ::libc::c_int, format: u16_);
pub fn ndspChnSetInterp(id: ::libc::c_int, type_: ndspInterpType);
pub fn ndspChnSetRate(id: ::libc::c_int, rate: f32);
pub fn ndspChnSetMix(id: ::libc::c_int, mix: *mut f32);
pub fn ndspChnSetAdpcmCoefs(id: ::libc::c_int, coefs: *mut u16_);
pub fn ndspChnWaveBufClear(id: ::libc::c_int);
pub fn ndspChnWaveBufAdd(id: ::libc::c_int, buf: *mut ndspWaveBuf);
pub fn ndspChnIirMonoSetEnable(id: ::libc::c_int, enable: u8);
pub fn ndspChnIirMonoSetParamsCustomFilter(id: ::libc::c_int, a0: f32,
a1: f32, b0: f32) -> u8;
pub fn ndspChnIirMonoSetParamsLowPassFilter(id: ::libc::c_int, f0: f32)
-> u8;
pub fn ndspChnIirMonoSetParamsHighPassFilter(id: ::libc::c_int, f0: f32)
-> u8;
pub fn ndspChnIirBiquadSetEnable(id: ::libc::c_int, enable: u8);
pub fn ndspChnIirBiquadSetParamsCustomFilter(id: ::libc::c_int, a0: f32,
a1: f32, a2: f32, b0: f32,
b1: f32, b2: f32) -> u8;
pub fn ndspChnIirBiquadSetParamsLowPassFilter(id: ::libc::c_int, f0: f32,
Q: f32) -> u8;
pub fn ndspChnIirBiquadSetParamsHighPassFilter(id: ::libc::c_int, f0: f32,
Q: f32) -> u8;
pub fn ndspChnIirBiquadSetParamsBandPassFilter(id: ::libc::c_int, f0: f32,
Q: f32) -> u8;
pub fn ndspChnIirBiquadSetParamsNotchFilter(id: ::libc::c_int, f0: f32,
Q: f32) -> u8;
pub fn ndspChnIirBiquadSetParamsPeakingEqualizer(id: ::libc::c_int,
f0: f32, Q: f32,
gain: f32) -> u8;
}

2
ctru-sys/src/ndsp/mod.rs
Unescape View File

@ -1,2 +0,0 @@
pub mod channel;
pub mod ndsp;

112
ctru-sys/src/ndsp/ndsp.rs
Unescape View File

@ -1,112 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ndspOutputMode {
NDSP_OUTPUT_MONO = 0,
NDSP_OUTPUT_STEREO = 1,
NDSP_OUTPUT_SURROUND = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ndspClippingMode { NDSP_CLIP_NORMAL = 0, NDSP_CLIP_SOFT = 1, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ndspSpeakerPos {
NDSP_SPKPOS_SQUARE = 0,
NDSP_SPKPOS_WIDE = 1,
NDSP_SPKPOS_NUM = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ndspAdpcmData {
pub index: u16_,
pub history0: s16,
pub history1: s16,
}
impl ::core::default::Default for ndspAdpcmData {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ndspWaveBuf = tag_ndspWaveBuf;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
NDSP_WBUF_FREE = 0,
NDSP_WBUF_QUEUED = 1,
NDSP_WBUF_PLAYING = 2,
NDSP_WBUF_DONE = 3,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct tag_ndspWaveBuf {
pub _bindgen_data_1_: [u64; 1usize],
pub nsamples: u32_,
pub adpcm_data: *mut ndspAdpcmData,
pub offset: u32_,
pub looping: u8,
pub status: u8_,
pub sequence_id: u16_,
pub next: *mut ndspWaveBuf,
}
impl tag_ndspWaveBuf {
pub unsafe fn data_pcm8(&mut self) -> *mut *mut s8 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn data_pcm16(&mut self) -> *mut *mut s16 {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn data_adpcm(&mut self) -> *mut *mut u8_ {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn data_vaddr(&mut self) -> *mut *const ::libc::c_void {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
}
impl ::core::default::Default for tag_ndspWaveBuf {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type ndspCallback =
::core::option::Option<unsafe extern "C" fn(data: *mut ::libc::c_void)>;
pub type ndspAuxCallback =
::core::option::Option<unsafe extern "C" fn(data: *mut ::libc::c_void,
nsamples: ::libc::c_int,
samples:
*mut *mut ::libc::c_void)>;
extern "C" {
pub fn ndspUseComponent(binary: *const ::libc::c_void, size: u32_,
progMask: u16_, dataMask: u16_);
pub fn ndspInit() -> Result;
pub fn ndspExit();
pub fn ndspGetDroppedFrames() -> u32_;
pub fn ndspGetFrameCount() -> u32_;
pub fn ndspSetMasterVol(volume: f32);
pub fn ndspSetOutputMode(mode: ndspOutputMode);
pub fn ndspSetClippingMode(mode: ndspClippingMode);
pub fn ndspSetOutputCount(count: ::libc::c_int);
pub fn ndspSetCapture(capture: *mut ndspWaveBuf);
pub fn ndspSetCallback(callback: ndspCallback, data: *mut ::libc::c_void);
pub fn ndspSurroundSetDepth(depth: u16_);
pub fn ndspSurroundSetPos(pos: ndspSpeakerPos);
pub fn ndspSurroundSetRearRatio(ratio: u16_);
pub fn ndspAuxSetEnable(id: ::libc::c_int, enable: u8);
pub fn ndspAuxSetFrontBypass(id: ::libc::c_int, bypass: u8);
pub fn ndspAuxSetVolume(id: ::libc::c_int, volume: f32);
pub fn ndspAuxSetCallback(id: ::libc::c_int, callback: ndspAuxCallback,
data: *mut ::libc::c_void);
}
use ::types::*;

47
ctru-sys/src/os.rs
Unescape View File

@ -1,47 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum MemRegion {
MEMREGION_ALL = 0,
MEMREGION_APPLICATION = 1,
MEMREGION_SYSTEM = 2,
MEMREGION_BASE = 3,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct OS_VersionBin {
pub build: u8_,
pub minor: u8_,
pub mainver: u8_,
pub reserved_x3: u8_,
pub region: ::libc::c_char,
pub reserved_x5: [u8_; 3usize],
}
impl ::core::default::Default for OS_VersionBin {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn osConvertVirtToPhys(vaddr: *const ::libc::c_void) -> u32_;
pub fn osConvertOldLINEARMemToNew(vaddr: *const ::libc::c_void)
-> *mut ::libc::c_void;
pub fn osStrError(error: u32_) -> *const ::libc::c_char;
pub fn osGetMemRegionUsed(region: MemRegion) -> s64;
pub fn osGetTime() -> u64_;
pub fn osSetSpeedupEnable(enable: u8);
pub fn osGetSystemVersionData(nver_versionbin: *mut OS_VersionBin,
cver_versionbin: *mut OS_VersionBin)
-> Result;
pub fn osGetSystemVersionDataString(nver_versionbin: *mut OS_VersionBin,
cver_versionbin: *mut OS_VersionBin,
sysverstr: *mut ::libc::c_char,
sysverstr_maxsize: u32_) -> Result;
}
use ::types::*;

54
ctru-sys/src/result.rs
Unescape View File

@ -1,54 +0,0 @@
//TODO: Implement C macro functions? Maybe?
//Result code level values
pub const RL_SUCCESS :i32 = 0;
pub const RL_INFO :i32 = 1;
pub const RL_FATAL :i32 = 31;
pub const RL_RESET :i32 = 30;
pub const RL_REINITIALIZE :i32 = 29;
pub const RL_USAGE :i32 = 28;
pub const RL_PERMANENT :i32 = 27;
pub const RL_TEMPORARY :i32 = 26;
pub const RL_STATUS :i32 = 25;
//Result code summary values
pub const RS_SUCCESS :i32 = 0;
pub const RS_NOP :i32 = 1;
pub const RS_WOULDBLOCK :i32 = 2;
pub const RS_OUTOFRESOURCE :i32 = 3;
pub const RS_NOTFOUND :i32 = 4;
pub const RS_INVALIDSTATE :i32 = 5;
pub const RS_NOTSUPPORTED :i32 = 6;
pub const RS_INVALIDARG :i32 = 7;
pub const RS_WRONGARG :i32 = 8;
pub const RS_CANCELED :i32 = 9;
pub const RS_STATUSCHANGED :i32 = 10;
pub const RS_INTERNAL :i32 = 11;
pub const RS_INVALIDRESVAL :i32 = 63;
//Result code generic description values
pub const RD_SUCCESS :i32 = 0;
pub const RD_INVALID_RESULT_VALUE :i32 = 1023;
pub const RD_TIMEOUT :i32 = 1022;
pub const RD_OUT_OF_RANGE :i32 = 1021;
pub const RD_ALREADY_EXISTS :i32 = 1020;
pub const RD_CANCEL_REQUESTED :i32 = 1019;
pub const RD_NOT_FOUND :i32 = 1018;
pub const RD_ALREADY_INITIALIZED :i32 = 1017;
pub const RD_NOT_INITIALIZED :i32 = 1016;
pub const RD_INVALID_HANDLE :i32 = 1015;
pub const RD_INVALID_POINTER :i32 = 1014;
pub const RD_INVALID_ADDRESS :i32 = 1013;
pub const RD_NOT_IMPLEMENTED :i32 = 1012;
pub const RD_OUT_OF_MEMORY :i32 = 1011;
pub const RD_MISALIGNED_SIZE :i32 = 1010;
pub const RD_MISALIGNED_ADDRESS :i32 = 1009;
pub const RD_BUSY :i32 = 1008;
pub const RD_NO_DATA :i32 = 1007;
pub const RD_INVALID_COMBINATION :i32 = 1006;
pub const RD_INVALID_ENUM_VALUE :i32 = 1005;
pub const RD_INVALID_SIZE :i32 = 1004;
pub const RD_ALREADY_DONE :i32 = 1003;
pub const RD_NOT_AUTHORIZED :i32 = 1002;
pub const RD_TOO_LARGE :i32 = 1001;
pub const RD_INVALID_SELECTION :i32 = 1000;

64
ctru-sys/src/romfs.rs
Unescape View File

@ -1,64 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct romfs_header {
pub headerSize: u32_,
pub dirHashTableOff: u32_,
pub dirHashTableSize: u32_,
pub dirTableOff: u32_,
pub dirTableSize: u32_,
pub fileHashTableOff: u32_,
pub fileHashTableSize: u32_,
pub fileTableOff: u32_,
pub fileTableSize: u32_,
pub fileDataOff: u32_,
}
impl ::core::default::Default for romfs_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct romfs_dir {
pub parent: u32_,
pub sibling: u32_,
pub childDir: u32_,
pub childFile: u32_,
pub nextHash: u32_,
pub nameLen: u32_,
pub name: [u16_; 0usize],
}
impl ::core::default::Default for romfs_dir {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct romfs_file {
pub parent: u32_,
pub sibling: u32_,
pub dataOff: u64_,
pub dataSize: u64_,
pub nextHash: u32_,
pub nameLen: u32_,
pub name: [u16_; 0usize],
}
impl ::core::default::Default for romfs_file {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub enum romfs_mount { }
extern "C" {
pub fn romfsMount(mount: *mut *mut romfs_mount) -> Result;
pub fn romfsMountFromFile(file: Handle, offset: u32_,
mount: *mut *mut romfs_mount) -> Result;
pub fn romfsBind(mount: *mut romfs_mount) -> Result;
pub fn romfsUnmount(mount: *mut romfs_mount) -> Result;
}
use ::types::*;

29
ctru-sys/src/sdmc.rs
Unescape View File

@ -1,29 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
use ::types::*;
use services::fs::FS_DirectoryEntry;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sdmc_dir_t {
pub magic: u32_,
pub fd: Handle,
pub index: ::libc::ssize_t,
pub size: ::libc::size_t,
pub entry_data: [FS_DirectoryEntry; 32usize],
}
impl ::core::default::Default for sdmc_dir_t {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn sdmcInit() -> Result;
pub fn sdmcWriteSafe(enable: u8);
pub fn sdmcExit() -> Result;
pub fn sdmc_getmtime(name: *const ::libc::c_char, mtime: *mut u64_)
-> Result;
}

13
ctru-sys/src/services/ac.rs
Unescape View File

@ -1,13 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn acInit() -> Result;
pub fn acExit();
pub fn acWaitInternetConnection() -> Result;
pub fn ACU_GetWifiStatus(out: *mut u32_) -> Result;
}
use ::types::*;

186
ctru-sys/src/services/am.rs
Unescape View File

@ -1,186 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct AM_TitleEntry {
pub titleID: u64_,
pub size: u64_,
pub version: u16_,
pub unk: [u8_; 6usize],
}
impl ::core::default::Default for AM_TitleEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
AM_STATUS_MASK_INSTALLING = 1,
AM_STATUS_MASK_AWAITING_FINALIZATION = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum AM_InstallStatus {
AM_STATUS_ABORTED = 2,
AM_STATUS_SAVED = 3,
AM_STATUS_INSTALL_IN_PROGRESS = 2050,
AM_STATUS_AWAITING_FINALIZATION = 2051,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct AM_PendingTitleEntry {
pub titleId: u64_,
pub version: u16_,
pub status: u16_,
pub titleType: u32_,
pub unk: [u8_; 8usize],
}
impl ::core::default::Default for AM_PendingTitleEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed2 {
AM_DELETE_PENDING_NON_SYSTEM = 1,
AM_DELETE_PENDING_SYSTEM = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct AM_TWLPartitionInfo {
pub capacity: u64_,
pub freeSpace: u64_,
pub titlesCapacity: u64_,
pub titlesFreeSpace: u64_,
}
impl ::core::default::Default for AM_TWLPartitionInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn amInit() -> Result;
pub fn amAppInit() -> Result;
pub fn amExit();
pub fn amGetSessionHandle() -> *mut Handle;
pub fn AM_GetTitleCount(mediatype: FS_MediaType, count: *mut u32_)
-> Result;
pub fn AM_GetTitleList(titlesRead: *mut u32_, mediatype: FS_MediaType,
titleCount: u32_, titleIds: *mut u64_) -> Result;
pub fn AM_GetTitleInfo(mediatype: FS_MediaType, titleCount: u32_,
titleIds: *mut u64_, titleInfo: *mut AM_TitleEntry)
-> Result;
pub fn AM_GetTicketCount(count: *mut u32_) -> Result;
pub fn AM_GetTicketList(ticketsRead: *mut u32_, ticketCount: u32_,
skip: u32_, ticketIds: *mut u64_) -> Result;
pub fn AM_GetPendingTitleCount(count: *mut u32_, mediatype: FS_MediaType,
statusMask: u32_) -> Result;
pub fn AM_GetPendingTitleList(titlesRead: *mut u32_, titleCount: u32_,
mediatype: FS_MediaType, statusMask: u32_,
titleIds: *mut u64_) -> Result;
pub fn AM_GetPendingTitleInfo(titleCount: u32_, mediatype: FS_MediaType,
titleIds: *mut u64_,
titleInfo: *mut AM_PendingTitleEntry)
-> Result;
pub fn AM_GetDeviceId(deviceID: *mut u32_) -> Result;
pub fn AM_ExportTwlBackup(titleID: u64_, operation: u8_,
workbuf: *mut ::libc::c_void,
workbuf_size: u32_,
filepath: *const ::libc::c_char) -> Result;
pub fn AM_ImportTwlBackup(filehandle: Handle, operation: u8_,
buffer: *mut ::libc::c_void, size: u32_)
-> Result;
pub fn AM_ReadTwlBackupInfo(filehandle: Handle,
outinfo: *mut ::libc::c_void,
outinfo_size: u32_,
workbuf: *mut ::libc::c_void,
workbuf_size: u32_,
banner: *mut ::libc::c_void,
banner_size: u32_) -> Result;
pub fn AM_GetTWLPartitionInfo(info: *mut AM_TWLPartitionInfo) -> Result;
pub fn AM_StartCiaInstall(mediatype: FS_MediaType, ciaHandle: *mut Handle)
-> Result;
pub fn AM_StartDlpChildCiaInstall(ciaHandle: *mut Handle) -> Result;
pub fn AM_CancelCIAInstall(ciaHandle: Handle) -> Result;
pub fn AM_FinishCiaInstall(ciaHandle: Handle) -> Result;
pub fn AM_DeleteTitle(mediatype: FS_MediaType, titleID: u64_) -> Result;
pub fn AM_DeleteAppTitle(mediatype: FS_MediaType, titleID: u64_)
-> Result;
pub fn AM_DeleteTicket(ticketId: u64_) -> Result;
pub fn AM_DeletePendingTitle(mediatype: FS_MediaType, titleId: u64_)
-> Result;
pub fn AM_DeletePendingTitles(mediatype: FS_MediaType, flags: u32_)
-> Result;
pub fn AM_DeleteAllPendingTitles(mediatype: FS_MediaType) -> Result;
pub fn AM_InstallNativeFirm() -> Result;
pub fn AM_InstallFirm(titleID: u64_) -> Result;
pub fn AM_GetTitleProductCode(mediatype: FS_MediaType, titleId: u64_,
productCode: *mut ::libc::c_char) -> Result;
pub fn AM_GetTitleExtDataId(extDataId: *mut u64_, mediatype: FS_MediaType,
titleId: u64_) -> Result;
pub fn AM_GetCiaFileInfo(mediatype: FS_MediaType,
titleEntry: *mut AM_TitleEntry,
fileHandle: Handle) -> Result;
pub fn AM_GetCiaIcon(icon: *mut ::libc::c_void, fileHandle: Handle)
-> Result;
pub fn AM_GetCiaDependencies(dependencies: *mut u64_, fileHandle: Handle)
-> Result;
pub fn AM_GetCiaMetaOffset(metaOffset: *mut u64_, fileHandle: Handle)
-> Result;
pub fn AM_GetCiaCoreVersion(coreVersion: *mut u32_, fileHandle: Handle)
-> Result;
pub fn AM_GetCiaRequiredSpace(requiredSpace: *mut u64_,
mediaType: FS_MediaType, fileHandle: Handle)
-> Result;
pub fn AM_GetCiaMetaSection(meta: *mut ::libc::c_void, size: u32_,
fileHandle: Handle) -> Result;
pub fn AM_InitializeExternalTitleDatabase(overwrite: u8) -> Result;
pub fn AM_QueryAvailableExternalTitleDatabase(available: *mut u8)
-> Result;
pub fn AM_InstallTicketBegin(ticketHandle: *mut Handle) -> Result;
pub fn AM_InstallTicketAbort(ticketHandle: Handle) -> Result;
pub fn AM_InstallTicketFinish(ticketHandle: Handle) -> Result;
pub fn AM_InstallTitleBegin(mediaType: FS_MediaType, titleId: u64_,
unk: u8) -> Result;
pub fn AM_InstallTitleStop() -> Result;
pub fn AM_InstallTitleResume(mediaType: FS_MediaType, titleId: u64_)
-> Result;
pub fn AM_InstallTitleAbort() -> Result;
pub fn AM_InstallTitleFinish() -> Result;
pub fn AM_CommitImportTitles(mediaType: FS_MediaType, titleCount: u32_,
temp: u8, titleIds: *mut u64_) -> Result;
pub fn AM_InstallTmdBegin(tmdHandle: *mut Handle) -> Result;
pub fn AM_InstallTmdAbort(tmdHandle: Handle) -> Result;
pub fn AM_InstallTmdFinish(tmdHandle: Handle, unk: u8) -> Result;
pub fn AM_CreateImportContentContexts(contentCount: u32_,
contentIndices: *mut u16_)
-> Result;
pub fn AM_InstallContentBegin(contentHandle: *mut Handle, index: u16_)
-> Result;
pub fn AM_InstallContentStop(contentHandle: Handle) -> Result;
pub fn AM_InstallContentResume(contentHandle: *mut Handle,
resumeOffset: *mut u64_, index: u16_)
-> Result;
pub fn AM_InstallContentCancel(contentHandle: Handle) -> Result;
pub fn AM_InstallContentFinish(contentHandle: Handle) -> Result;
pub fn AM_ImportCertificates(cert1Size: u32_, cert1: *mut ::libc::c_void,
cert2Size: u32_, cert2: *mut ::libc::c_void,
cert3Size: u32_, cert3: *mut ::libc::c_void,
cert4Size: u32_, cert4: *mut ::libc::c_void)
-> Result;
pub fn AM_ImportCertificate(certSize: u32_, cert: *mut ::libc::c_void)
-> Result;
pub fn AM_CommitImportTitlesAndUpdateFirmwareAuto(mediaType: FS_MediaType,
titleCount: u32_,
temp: u8,
titleIds: *mut u64_)
-> Result;
}
use ::types::*;
use super::fs::FS_MediaType;

18
ctru-sys/src/services/ampxi.rs
Unescape View File

@ -1,18 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn ampxiInit(servhandle: Handle) -> Result;
pub fn ampxiExit();
pub fn AMPXI_WriteTWLSavedata(titleid: u64_, buffer: *mut u8_, size: u32_,
image_filepos: u32_, section_type: u8_,
operation: u8_) -> Result;
pub fn AMPXI_InstallTitlesFinish(mediaType: FS_MediaType, db: u8_,
titlecount: u32_, tidlist: *mut u64_)
-> Result;
}
use ::types::*;
use super::fs::FS_MediaType;

241
ctru-sys/src/services/apt.rs
Unescape View File

@ -1,241 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum NS_APPID {
APPID_NONE = 0,
APPID_HOMEMENU = 257,
APPID_CAMERA = 272,
APPID_FRIENDS_LIST = 274,
APPID_GAME_NOTES = 275,
APPID_WEB = 276,
APPID_INSTRUCTION_MANUAL = 277,
APPID_NOTIFICATIONS = 278,
APPID_MIIVERSE = 279,
APPID_MIIVERSE_POSTING = 280,
APPID_AMIIBO_SETTINGS = 281,
APPID_APPLICATION = 768,
APPID_ESHOP = 769,
APPID_SOFTWARE_KEYBOARD = 1025,
APPID_APPLETED = 1026,
APPID_PNOTE_AP = 1028,
APPID_SNOTE_AP = 1029,
APPID_ERROR = 1030,
APPID_MINT = 1031,
APPID_EXTRAPAD = 1032,
APPID_MEMOLIB = 1033,
}
#[derive(Copy, Clone)]
#[repr(i32)]
#[derive(Debug)]
pub enum APT_AppletPos {
APTPOS_NONE = -1,
APTPOS_APP = 0,
APTPOS_APPLIB = 1,
APTPOS_SYS = 2,
APTPOS_SYSLIB = 3,
APTPOS_RESIDENT = 4,
}
pub type APT_AppletAttr = u8_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum APT_QueryReply {
APTREPLY_REJECT = 0,
APTREPLY_ACCEPT = 1,
APTREPLY_LATER = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum APT_Signal {
APTSIGNAL_NONE = 0,
APTSIGNAL_HOMEBUTTON = 1,
APTSIGNAL_HOMEBUTTON2 = 2,
APTSIGNAL_SLEEP_QUERY = 3,
APTSIGNAL_SLEEP_CANCEL = 4,
APTSIGNAL_SLEEP_ENTER = 5,
APTSIGNAL_SLEEP_WAKEUP = 6,
APTSIGNAL_SHUTDOWN = 7,
APTSIGNAL_POWERBUTTON = 8,
APTSIGNAL_POWERBUTTON2 = 9,
APTSIGNAL_TRY_SLEEP = 10,
APTSIGNAL_ORDERTOCLOSE = 11,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum APT_Command {
APTCMD_NONE = 0,
APTCMD_WAKEUP = 1,
APTCMD_REQUEST = 2,
APTCMD_RESPONSE = 3,
APTCMD_EXIT = 4,
APTCMD_MESSAGE = 5,
APTCMD_HOMEBUTTON_ONCE = 6,
APTCMD_HOMEBUTTON_TWICE = 7,
APTCMD_DSP_SLEEP = 8,
APTCMD_DSP_WAKEUP = 9,
APTCMD_WAKEUP_EXIT = 10,
APTCMD_WAKEUP_PAUSE = 11,
APTCMD_WAKEUP_CANCEL = 12,
APTCMD_WAKEUP_CANCELALL = 13,
APTCMD_WAKEUP_POWERBUTTON = 14,
APTCMD_WAKEUP_JUMPTOHOME = 15,
APTCMD_SYSAPPLET_REQUEST = 16,
APTCMD_WAKEUP_LAUNCHAPP = 17,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct aptCaptureBufInfo {
pub size: u32_,
pub is3D: u32_,
pub top: Struct_Unnamed1,
pub bottom: Struct_Unnamed1,
}
impl ::core::default::Default for aptCaptureBufInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed1 {
pub leftOffset: u32_,
pub rightOffset: u32_,
pub format: u32_,
}
impl ::core::default::Default for Struct_Unnamed1 {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum APT_HookType {
APTHOOK_ONSUSPEND = 0,
APTHOOK_ONRESTORE = 1,
APTHOOK_ONSLEEP = 2,
APTHOOK_ONWAKEUP = 3,
APTHOOK_ONEXIT = 4,
APTHOOK_COUNT = 5,
}
pub type aptHookFn =
::core::option::Option<unsafe extern "C" fn(hook: APT_HookType,
param: *mut ::libc::c_void)>;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct tag_aptHookCookie {
pub next: *mut tag_aptHookCookie,
pub callback: aptHookFn,
pub param: *mut ::libc::c_void,
}
impl ::core::default::Default for tag_aptHookCookie {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type aptHookCookie = tag_aptHookCookie;
pub type aptMessageCb =
::core::option::Option<unsafe extern "C" fn(user: *mut ::libc::c_void,
sender: NS_APPID,
msg: *mut ::libc::c_void,
msgsize: ::libc::size_t)>;
extern "C" {
pub fn aptInit() -> Result;
pub fn aptExit();
pub fn aptSendCommand(aptcmdbuf: *mut u32_) -> Result;
pub fn aptIsSleepAllowed() -> u8;
pub fn aptSetSleepAllowed(allowed: u8);
pub fn aptMainLoop() -> u8;
pub fn aptHook(cookie: *mut aptHookCookie, callback: aptHookFn,
param: *mut ::libc::c_void);
pub fn aptUnhook(cookie: *mut aptHookCookie);
pub fn aptSetMessageCallback(callback: aptMessageCb,
user: *mut ::libc::c_void);
pub fn aptLaunchLibraryApplet(appId: NS_APPID, buf: *mut ::libc::c_void,
bufsize: ::libc::size_t, handle: Handle) -> u8;
pub fn APT_GetLockHandle(flags: u16_, lockHandle: *mut Handle) -> Result;
pub fn APT_Initialize(appId: NS_APPID, attr: APT_AppletAttr,
signalEvent: *mut Handle, resumeEvent: *mut Handle)
-> Result;
pub fn APT_Finalize(appId: NS_APPID) -> Result;
pub fn APT_HardwareResetAsync() -> Result;
pub fn APT_Enable(attr: APT_AppletAttr) -> Result;
pub fn APT_GetAppletManInfo(inpos: APT_AppletPos,
outpos: *mut APT_AppletPos,
req_appid: *mut NS_APPID,
menu_appid: *mut NS_APPID,
active_appid: *mut NS_APPID) -> Result;
pub fn APT_GetAppletInfo(appID: NS_APPID, pProgramID: *mut u64_,
pMediaType: *mut u8_, pRegistered: *mut u8,
pLoadState: *mut u8,
pAttributes: *mut APT_AppletAttr) -> Result;
pub fn APT_GetAppletProgramInfo(id: u32_, flags: u32_,
titleversion: *mut u16_) -> Result;
pub fn APT_GetProgramID(pProgramID: *mut u64_) -> Result;
pub fn APT_PrepareToJumpToHomeMenu() -> Result;
pub fn APT_JumpToHomeMenu(param: *const ::libc::c_void, paramSize: ::libc::size_t,
handle: Handle) -> Result;
pub fn APT_PrepareToJumpToApplication(exiting: u8) -> Result;
pub fn APT_JumpToApplication(param: *const ::libc::c_void,
paramSize: ::libc::size_t, handle: Handle) -> Result;
pub fn APT_IsRegistered(appID: NS_APPID, out: *mut u8) -> Result;
pub fn APT_InquireNotification(appID: u32_, signalType: *mut APT_Signal)
-> Result;
pub fn APT_NotifyToWait(appID: NS_APPID) -> Result;
pub fn APT_AppletUtility(id: ::libc::c_int, out: *mut ::libc::c_void,
outSize: ::libc::size_t, in_: *const ::libc::c_void,
inSize: ::libc::size_t) -> Result;
pub fn APT_SleepIfShellClosed() -> Result;
pub fn APT_TryLockTransition(transition: u32_, succeeded: *mut u8)
-> Result;
pub fn APT_UnlockTransition(transition: u32_) -> Result;
pub fn APT_GlanceParameter(appID: NS_APPID, buffer: *mut ::libc::c_void,
bufferSize: ::libc::size_t, sender: *mut NS_APPID,
command: *mut APT_Command,
actualSize: *mut ::libc::size_t,
parameter: *mut Handle) -> Result;
pub fn APT_ReceiveParameter(appID: NS_APPID, buffer: *mut ::libc::c_void,
bufferSize: ::libc::size_t, sender: *mut NS_APPID,
command: *mut APT_Command,
actualSize: *mut ::libc::size_t,
parameter: *mut Handle) -> Result;
pub fn APT_SendParameter(source: NS_APPID, dest: NS_APPID,
command: APT_Command,
buffer: *const ::libc::c_void, bufferSize: u32_,
parameter: Handle) -> Result;
pub fn APT_CancelParameter(source: NS_APPID, dest: NS_APPID,
success: *mut u8) -> Result;
pub fn APT_SendCaptureBufferInfo(captureBuf: *const aptCaptureBufInfo)
-> Result;
pub fn APT_ReplySleepQuery(appID: NS_APPID, reply: APT_QueryReply)
-> Result;
pub fn APT_ReplySleepNotificationComplete(appID: NS_APPID) -> Result;
pub fn APT_PrepareToCloseApplication(cancelPreload: u8) -> Result;
pub fn APT_CloseApplication(param: *const ::libc::c_void,
paramSize: ::libc::size_t, handle: Handle) -> Result;
pub fn APT_SetAppCpuTimeLimit(percent: u32_) -> Result;
pub fn APT_GetAppCpuTimeLimit(percent: *mut u32_) -> Result;
pub fn APT_CheckNew3DS(out: *mut u8) -> Result;
pub fn APT_PrepareToDoApplicationJump(flags: u8_, programID: u64_,
mediatype: u8_) -> Result;
pub fn APT_DoApplicationJump(param: *const ::libc::c_void,
paramSize: ::libc::size_t,
hmac: *const ::libc::c_void) -> Result;
pub fn APT_PrepareToStartLibraryApplet(appID: NS_APPID) -> Result;
pub fn APT_StartLibraryApplet(appID: NS_APPID,
param: *const ::libc::c_void,
paramSize: ::libc::size_t, handle: Handle)
-> Result;
pub fn APT_PrepareToStartSystemApplet(appID: NS_APPID) -> Result;
pub fn APT_StartSystemApplet(appID: NS_APPID,
param: *const ::libc::c_void,
paramSize: ::libc::size_t, handle: Handle) -> Result;
pub fn APT_GetSharedFont(fontHandle: *mut Handle, mapAddr: *mut u32_)
-> Result;
}
use ::types::*;

392
ctru-sys/src/services/cam.rs
Unescape View File

@ -1,392 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
PORT_NONE = 0,
PORT_CAM1 = 1,
PORT_CAM2 = 2,
PORT_BOTH = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed2 {
SELECT_NONE = 0,
SELECT_OUT1 = 1,
SELECT_IN1 = 2,
SELECT_OUT2 = 4,
SELECT_IN1_OUT1 = 3,
SELECT_OUT1_OUT2 = 5,
SELECT_IN1_OUT2 = 6,
SELECT_ALL = 7,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_Context {
CONTEXT_NONE = 0,
CONTEXT_A = 1,
CONTEXT_B = 2,
CONTEXT_BOTH = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_Flip {
FLIP_NONE = 0,
FLIP_HORIZONTAL = 1,
FLIP_VERTICAL = 2,
FLIP_REVERSE = 3,
}
pub const SIZE_CTR_BOTTOM_LCD: CAMU_Size = CAMU_Size::SIZE_QVGA;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_Size {
SIZE_VGA = 0,
SIZE_QVGA = 1,
SIZE_QQVGA = 2,
SIZE_CIF = 3,
SIZE_QCIF = 4,
SIZE_DS_LCD = 5,
SIZE_DS_LCDx4 = 6,
SIZE_CTR_TOP_LCD = 7,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_FrameRate {
FRAME_RATE_15 = 0,
FRAME_RATE_15_TO_5 = 1,
FRAME_RATE_15_TO_2 = 2,
FRAME_RATE_10 = 3,
FRAME_RATE_8_5 = 4,
FRAME_RATE_5 = 5,
FRAME_RATE_20 = 6,
FRAME_RATE_20_TO_5 = 7,
FRAME_RATE_30 = 8,
FRAME_RATE_30_TO_5 = 9,
FRAME_RATE_15_TO_10 = 10,
FRAME_RATE_20_TO_10 = 11,
FRAME_RATE_30_TO_10 = 12,
}
pub const WHITE_BALANCE_NORMAL: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_AUTO;
pub const WHITE_BALANCE_TUNGSTEN: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_3200K;
pub const WHITE_BALANCE_WHITE_FLUORESCENT_LIGHT: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_4150K;
pub const WHITE_BALANCE_DAYLIGHT: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_5200K;
pub const WHITE_BALANCE_CLOUDY: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_6000K;
pub const WHITE_BALANCE_HORIZON: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_6000K;
pub const WHITE_BALANCE_SHADE: CAMU_WhiteBalance =
CAMU_WhiteBalance::WHITE_BALANCE_7000K;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_WhiteBalance {
WHITE_BALANCE_AUTO = 0,
WHITE_BALANCE_3200K = 1,
WHITE_BALANCE_4150K = 2,
WHITE_BALANCE_5200K = 3,
WHITE_BALANCE_6000K = 4,
WHITE_BALANCE_7000K = 5,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_PhotoMode {
PHOTO_MODE_NORMAL = 0,
PHOTO_MODE_PORTRAIT = 1,
PHOTO_MODE_LANDSCAPE = 2,
PHOTO_MODE_NIGHTVIEW = 3,
PHOTO_MODE_LETTER = 4,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_Effect {
EFFECT_NONE = 0,
EFFECT_MONO = 1,
EFFECT_SEPIA = 2,
EFFECT_NEGATIVE = 3,
EFFECT_NEGAFILM = 4,
EFFECT_SEPIA01 = 5,
}
pub const CONTRAST_LOW: CAMU_Contrast = CAMU_Contrast::CONTRAST_PATTERN_05;
pub const CONTRAST_NORMAL: CAMU_Contrast = CAMU_Contrast::CONTRAST_PATTERN_06;
pub const CONTRAST_HIGH: CAMU_Contrast = CAMU_Contrast::CONTRAST_PATTERN_07;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_Contrast {
CONTRAST_PATTERN_01 = 0,
CONTRAST_PATTERN_02 = 1,
CONTRAST_PATTERN_03 = 2,
CONTRAST_PATTERN_04 = 3,
CONTRAST_PATTERN_05 = 4,
CONTRAST_PATTERN_06 = 5,
CONTRAST_PATTERN_07 = 6,
CONTRAST_PATTERN_08 = 7,
CONTRAST_PATTERN_09 = 8,
CONTRAST_PATTERN_10 = 9,
CONTRAST_PATTERN_11 = 10,
}
pub const LENS_CORRECTION_DARK: CAMU_LensCorrection =
CAMU_LensCorrection::LENS_CORRECTION_OFF;
pub const LENS_CORRECTION_NORMAL: CAMU_LensCorrection =
CAMU_LensCorrection::LENS_CORRECTION_ON_70;
pub const LENS_CORRECTION_BRIGHT: CAMU_LensCorrection =
CAMU_LensCorrection::LENS_CORRECTION_ON_90;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_LensCorrection {
LENS_CORRECTION_OFF = 0,
LENS_CORRECTION_ON_70 = 1,
LENS_CORRECTION_ON_90 = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_OutputFormat { OUTPUT_YUV_422 = 0, OUTPUT_RGB_565 = 1, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CAMU_ShutterSoundType {
SHUTTER_SOUND_TYPE_NORMAL = 0,
SHUTTER_SOUND_TYPE_MOVIE = 1,
SHUTTER_SOUND_TYPE_MOVIE_END = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CAMU_ImageQualityCalibrationData {
pub aeBaseTarget: s16,
pub kRL: s16,
pub kGL: s16,
pub kBL: s16,
pub ccmPosition: s16,
pub awbCcmL9Right: u16_,
pub awbCcmL9Left: u16_,
pub awbCcmL10Right: u16_,
pub awbCcmL10Left: u16_,
pub awbX0Right: u16_,
pub awbX0Left: u16_,
}
impl ::core::default::Default for CAMU_ImageQualityCalibrationData {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CAMU_StereoCameraCalibrationData {
pub isValidRotationXY: u8_,
pub padding: [u8_; 3usize],
pub scale: f32,
pub rotationZ: f32,
pub translationX: f32,
pub translationY: f32,
pub rotationX: f32,
pub rotationY: f32,
pub angleOfViewRight: f32,
pub angleOfViewLeft: f32,
pub distanceToChart: f32,
pub distanceCameras: f32,
pub imageWidth: s16,
pub imageHeight: s16,
pub reserved: [u8_; 16usize],
}
impl ::core::default::Default for CAMU_StereoCameraCalibrationData {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CAMU_PackageParameterCameraSelect {
pub camera: u8_,
pub exposure: s8,
pub whiteBalance: u8_,
pub sharpness: s8,
pub autoExposureOn: u8_,
pub autoWhiteBalanceOn: u8_,
pub frameRate: u8_,
pub photoMode: u8_,
pub contrast: u8_,
pub lensCorrection: u8_,
pub noiseFilterOn: u8_,
pub padding: u8_,
pub autoExposureWindowX: s16,
pub autoExposureWindowY: s16,
pub autoExposureWindowWidth: s16,
pub autoExposureWindowHeight: s16,
pub autoWhiteBalanceWindowX: s16,
pub autoWhiteBalanceWindowY: s16,
pub autoWhiteBalanceWindowWidth: s16,
pub autoWhiteBalanceWindowHeight: s16,
}
impl ::core::default::Default for CAMU_PackageParameterCameraSelect {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CAMU_PackageParameterContext {
pub camera: u8_,
pub context: u8_,
pub flip: u8_,
pub effect: u8_,
pub size: u8_,
}
impl ::core::default::Default for CAMU_PackageParameterContext {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CAMU_PackageParameterContextDetail {
pub camera: u8_,
pub context: u8_,
pub flip: u8_,
pub effect: u8_,
pub width: s16,
pub height: s16,
pub cropX0: s16,
pub cropY0: s16,
pub cropX1: s16,
pub cropY1: s16,
}
impl ::core::default::Default for CAMU_PackageParameterContextDetail {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn camInit() -> Result;
pub fn camExit();
pub fn CAMU_StartCapture(port: u32_) -> Result;
pub fn CAMU_StopCapture(port: u32_) -> Result;
pub fn CAMU_IsBusy(busy: *mut u8, port: u32_) -> Result;
pub fn CAMU_ClearBuffer(port: u32_) -> Result;
pub fn CAMU_GetVsyncInterruptEvent(event: *mut Handle, port: u32_)
-> Result;
pub fn CAMU_GetBufferErrorInterruptEvent(event: *mut Handle, port: u32_)
-> Result;
pub fn CAMU_SetReceiving(event: *mut Handle, dst: *mut ::libc::c_void,
port: u32_, imageSize: u32_, transferUnit: s16)
-> Result;
pub fn CAMU_IsFinishedReceiving(finishedReceiving: *mut u8, port: u32_)
-> Result;
pub fn CAMU_SetTransferLines(port: u32_, lines: s16, width: s16,
height: s16) -> Result;
pub fn CAMU_GetMaxLines(maxLines: *mut s16, width: s16, height: s16)
-> Result;
pub fn CAMU_SetTransferBytes(port: u32_, bytes: u32_, width: s16,
height: s16) -> Result;
pub fn CAMU_GetTransferBytes(transferBytes: *mut u32_, port: u32_)
-> Result;
pub fn CAMU_GetMaxBytes(maxBytes: *mut u32_, width: s16, height: s16)
-> Result;
pub fn CAMU_SetTrimming(port: u32_, trimming: u8) -> Result;
pub fn CAMU_IsTrimming(trimming: *mut u8, port: u32_) -> Result;
pub fn CAMU_SetTrimmingParams(port: u32_, xStart: s16, yStart: s16,
xEnd: s16, yEnd: s16) -> Result;
pub fn CAMU_GetTrimmingParams(xStart: *mut s16, yStart: *mut s16,
xEnd: *mut s16, yEnd: *mut s16, port: u32_)
-> Result;
pub fn CAMU_SetTrimmingParamsCenter(port: u32_, trimWidth: s16,
trimHeight: s16, camWidth: s16,
camHeight: s16) -> Result;
pub fn CAMU_Activate(select: u32_) -> Result;
pub fn CAMU_SwitchContext(select: u32_, context: CAMU_Context) -> Result;
pub fn CAMU_SetExposure(select: u32_, exposure: s8) -> Result;
pub fn CAMU_SetWhiteBalance(select: u32_, whiteBalance: CAMU_WhiteBalance)
-> Result;
pub fn CAMU_SetWhiteBalanceWithoutBaseUp(select: u32_,
whiteBalance: CAMU_WhiteBalance)
-> Result;
pub fn CAMU_SetSharpness(select: u32_, sharpness: s8) -> Result;
pub fn CAMU_SetAutoExposure(select: u32_, autoExposure: u8) -> Result;
pub fn CAMU_IsAutoExposure(autoExposure: *mut u8, select: u32_) -> Result;
pub fn CAMU_SetAutoWhiteBalance(select: u32_, autoWhiteBalance: u8)
-> Result;
pub fn CAMU_IsAutoWhiteBalance(autoWhiteBalance: *mut u8, select: u32_)
-> Result;
pub fn CAMU_FlipImage(select: u32_, flip: CAMU_Flip,
context: CAMU_Context) -> Result;
pub fn CAMU_SetDetailSize(select: u32_, width: s16, height: s16,
cropX0: s16, cropY0: s16, cropX1: s16,
cropY1: s16, context: CAMU_Context) -> Result;
pub fn CAMU_SetSize(select: u32_, size: CAMU_Size, context: CAMU_Context)
-> Result;
pub fn CAMU_SetFrameRate(select: u32_, frameRate: CAMU_FrameRate)
-> Result;
pub fn CAMU_SetPhotoMode(select: u32_, photoMode: CAMU_PhotoMode)
-> Result;
pub fn CAMU_SetEffect(select: u32_, effect: CAMU_Effect,
context: CAMU_Context) -> Result;
pub fn CAMU_SetContrast(select: u32_, contrast: CAMU_Contrast) -> Result;
pub fn CAMU_SetLensCorrection(select: u32_,
lensCorrection: CAMU_LensCorrection)
-> Result;
pub fn CAMU_SetOutputFormat(select: u32_, format: CAMU_OutputFormat,
context: CAMU_Context) -> Result;
pub fn CAMU_SetAutoExposureWindow(select: u32_, x: s16, y: s16,
width: s16, height: s16) -> Result;
pub fn CAMU_SetAutoWhiteBalanceWindow(select: u32_, x: s16, y: s16,
width: s16, height: s16) -> Result;
pub fn CAMU_SetNoiseFilter(select: u32_, noiseFilter: u8) -> Result;
pub fn CAMU_SynchronizeVsyncTiming(select1: u32_, select2: u32_)
-> Result;
pub fn CAMU_GetLatestVsyncTiming(timing: *mut s64, port: u32_, past: u32_)
-> Result;
pub fn CAMU_GetStereoCameraCalibrationData(data:
*mut CAMU_StereoCameraCalibrationData)
-> Result;
pub fn CAMU_SetStereoCameraCalibrationData(data:
CAMU_StereoCameraCalibrationData)
-> Result;
pub fn CAMU_WriteRegisterI2c(select: u32_, addr: u16_, data: u16_)
-> Result;
pub fn CAMU_WriteMcuVariableI2c(select: u32_, addr: u16_, data: u16_)
-> Result;
pub fn CAMU_ReadRegisterI2cExclusive(data: *mut u16_, select: u32_,
addr: u16_) -> Result;
pub fn CAMU_ReadMcuVariableI2cExclusive(data: *mut u16_, select: u32_,
addr: u16_) -> Result;
pub fn CAMU_SetImageQualityCalibrationData(data:
CAMU_ImageQualityCalibrationData)
-> Result;
pub fn CAMU_GetImageQualityCalibrationData(data:
*mut CAMU_ImageQualityCalibrationData)
-> Result;
pub fn CAMU_SetPackageParameterWithoutContext(param:
CAMU_PackageParameterCameraSelect)
-> Result;
pub fn CAMU_SetPackageParameterWithContext(param:
CAMU_PackageParameterContext)
-> Result;
pub fn CAMU_SetPackageParameterWithContextDetail(param:
CAMU_PackageParameterContextDetail)
-> Result;
pub fn CAMU_GetSuitableY2rStandardCoefficient(coefficient:
*mut Y2RU_StandardCoefficient)
-> Result;
pub fn CAMU_PlayShutterSound(sound: CAMU_ShutterSoundType) -> Result;
pub fn CAMU_DriverInitialize() -> Result;
pub fn CAMU_DriverFinalize() -> Result;
pub fn CAMU_GetActivatedCamera(select: *mut u32_) -> Result;
pub fn CAMU_GetSleepCamera(select: *mut u32_) -> Result;
pub fn CAMU_SetSleepCamera(select: u32_) -> Result;
pub fn CAMU_SetBrightnessSynchronization(brightnessSynchronization: u8)
-> Result;
}
use ::types::*;
use super::y2r::*;

19
ctru-sys/src/services/cfgnor.rs
Unescape View File

@ -1,19 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn cfgnorInit(value: u8_) -> Result;
pub fn cfgnorExit();
pub fn cfgnorDumpFlash(buf: *mut u32_, size: u32_) -> Result;
pub fn cfgnorWriteFlash(buf: *mut u32_, size: u32_) -> Result;
pub fn CFGNOR_Initialize(value: u8_) -> Result;
pub fn CFGNOR_Shutdown() -> Result;
pub fn CFGNOR_ReadData(offset: u32_, buf: *mut u32_, size: u32_)
-> Result;
pub fn CFGNOR_WriteData(offset: u32_, buf: *mut u32_, size: u32_)
-> Result;
}
use ::types::*;

60
ctru-sys/src/services/cfgu.rs
Unescape View File

@ -1,60 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CFG_Region {
CFG_REGION_JPN = 0,
CFG_REGION_USA = 1,
CFG_REGION_EUR = 2,
CFG_REGION_AUS = 3,
CFG_REGION_CHN = 4,
CFG_REGION_KOR = 5,
CFG_REGION_TWN = 6,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CFG_Language {
CFG_LANGUAGE_JP = 0,
CFG_LANGUAGE_EN = 1,
CFG_LANGUAGE_FR = 2,
CFG_LANGUAGE_DE = 3,
CFG_LANGUAGE_IT = 4,
CFG_LANGUAGE_ES = 5,
CFG_LANGUAGE_ZH = 6,
CFG_LANGUAGE_KO = 7,
CFG_LANGUAGE_NL = 8,
CFG_LANGUAGE_PT = 9,
CFG_LANGUAGE_RU = 10,
CFG_LANGUAGE_TW = 11,
}
extern "C" {
pub fn cfguInit() -> Result;
pub fn cfguExit();
pub fn CFGU_SecureInfoGetRegion(region: *mut u8_) -> Result;
pub fn CFGU_GenHashConsoleUnique(appIDSalt: u32_, hash: *mut u64_)
-> Result;
pub fn CFGU_GetRegionCanadaUSA(value: *mut u8_) -> Result;
pub fn CFGU_GetSystemModel(model: *mut u8_) -> Result;
pub fn CFGU_GetModelNintendo2DS(value: *mut u8_) -> Result;
pub fn CFGU_GetCountryCodeString(code: u16_, string: *mut u16_) -> Result;
pub fn CFGU_GetCountryCodeID(string: u16_, code: *mut u16_) -> Result;
pub fn CFGU_GetConfigInfoBlk2(size: u32_, blkID: u32_, outData: *mut u8_)
-> Result;
pub fn CFG_GetConfigInfoBlk4(size: u32_, blkID: u32_, outData: *mut u8_)
-> Result;
pub fn CFG_GetConfigInfoBlk8(size: u32_, blkID: u32_, outData: *mut u8_)
-> Result;
pub fn CFG_SetConfigInfoBlk4(size: u32_, blkID: u32_, inData: *mut u8_)
-> Result;
pub fn CFG_SetConfigInfoBlk8(size: u32_, blkID: u32_, inData: *mut u8_)
-> Result;
pub fn CFG_UpdateConfigNANDSavegame() -> Result;
pub fn CFGU_GetSystemLanguage(language: *mut u8_) -> Result;
}
use ::types::*;

45
ctru-sys/src/services/dsp.rs
Unescape View File

@ -1,45 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DSP_InterruptType { DSP_INTERRUPT_PIPE = 2, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DSP_PipeDirection { DSP_PIPE_INPUT = 0, DSP_PIPE_OUTPUT = 1, }
extern "C" {
pub fn dspInit() -> Result;
pub fn dspExit();
pub fn DSP_GetHeadphoneStatus(is_inserted: *mut u8) -> Result;
pub fn DSP_FlushDataCache(address: *const ::libc::c_void, size: u32_)
-> Result;
pub fn DSP_InvalidateDataCache(address: *const ::libc::c_void, size: u32_)
-> Result;
pub fn DSP_GetSemaphoreHandle(semaphore: *mut Handle) -> Result;
pub fn DSP_SetSemaphore(value: u16_) -> Result;
pub fn DSP_SetSemaphoreMask(mask: u16_) -> Result;
pub fn DSP_LoadComponent(component: *const ::libc::c_void, size: u32_,
prog_mask: u16_, data_mask: u16_,
is_loaded: *mut u8) -> Result;
pub fn DSP_UnloadComponent() -> Result;
pub fn DSP_RegisterInterruptEvents(handle: Handle, interrupt: u32_,
channel: u32_) -> Result;
pub fn DSP_ReadPipeIfPossible(channel: u32_, peer: u32_,
buffer: *mut ::libc::c_void, length: u16_,
length_read: *mut u16_) -> Result;
pub fn DSP_WriteProcessPipe(channel: u32_, buffer: *const ::libc::c_void,
length: u32_) -> Result;
pub fn DSP_ConvertProcessAddressFromDspDram(dsp_address: u32_,
arm_address: *mut u32_)
-> Result;
pub fn DSP_RecvData(regNo: u16_, value: *mut u16_) -> Result;
pub fn DSP_RecvDataIsReady(regNo: u16_, is_ready: *mut u8) -> Result;
pub fn DSP_SendData(regNo: u16_, value: u16_) -> Result;
pub fn DSP_SendDataIsEmpty(regNo: u16_, is_empty: *mut u8) -> Result;
}
use ::types::*;

547
ctru-sys/src/services/fs.rs
Unescape View File

@ -1,547 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
FS_OPEN_READ = 1,
FS_OPEN_WRITE = 2,
FS_OPEN_CREATE = 4,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed2 { FS_WRITE_FLUSH = 1, FS_WRITE_UPDATE_TIME = 256, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed3 {
FS_ATTRIBUTE_DIRECTORY = 1,
FS_ATTRIBUTE_HIDDEN = 256,
FS_ATTRIBUTE_ARCHIVE = 65536,
FS_ATTRIBUTE_READ_ONLY = 16777216,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_MediaType {
MEDIATYPE_NAND = 0,
MEDIATYPE_SD = 1,
MEDIATYPE_GAME_CARD = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_SystemMediaType {
SYSTEM_MEDIATYPE_CTR_NAND = 0,
SYSTEM_MEDIATYPE_TWL_NAND = 1,
SYSTEM_MEDIATYPE_SD = 2,
SYSTEM_MEDIATYPE_TWL_PHOTO = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_ArchiveID {
ARCHIVE_ROMFS = 3,
ARCHIVE_SAVEDATA = 4,
ARCHIVE_EXTDATA = 6,
ARCHIVE_SHARED_EXTDATA = 7,
ARCHIVE_SYSTEM_SAVEDATA = 8,
ARCHIVE_SDMC = 9,
ARCHIVE_SDMC_WRITE_ONLY = 10,
ARCHIVE_BOSS_EXTDATA = 305419896,
ARCHIVE_CARD_SPIFS = 305419897,
ARCHIVE_EXTDATA_AND_BOSS_EXTDATA = 305419899,
ARCHIVE_SYSTEM_SAVEDATA2 = 305419900,
ARCHIVE_NAND_RW = 305419901,
ARCHIVE_NAND_RO = 305419902,
ARCHIVE_NAND_RO_WRITE_ACCESS = 305419903,
ARCHIVE_SAVEDATA_AND_CONTENT = 591751050,
ARCHIVE_SAVEDATA_AND_CONTENT2 = 591751054,
ARCHIVE_NAND_CTR_FS = 1450741931,
ARCHIVE_TWL_PHOTO = 1450741932,
ARCHIVE_TWL_SOUND = 1450741933,
ARCHIVE_NAND_TWL_FS = 1450741934,
ARCHIVE_NAND_W_FS = 1450741935,
ARCHIVE_GAMECARD_SAVEDATA = 1450741937,
ARCHIVE_USER_SAVEDATA = 1450741938,
ARCHIVE_DEMO_SAVEDATA = 1450741940,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_PathType {
PATH_INVALID = 0,
PATH_EMPTY = 1,
PATH_BINARY = 2,
PATH_ASCII = 3,
PATH_UTF16 = 4,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_SecureValueSlot { SECUREVALUE_SLOT_SD = 4096, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_CardSpiBaudRate {
BAUDRATE_512KHZ = 0,
BAUDRATE_1MHZ = 1,
BAUDRATE_2MHZ = 2,
BAUDRATE_4MHZ = 3,
BAUDRATE_8MHZ = 4,
BAUDRATE_16MHZ = 5,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_CardSpiBusMode { BUSMODE_1BIT = 0, BUSMODE_4BIT = 1, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_SpecialContentType {
SPECIALCONTENT_UPDATE = 1,
SPECIALCONTENT_MANUAL = 2,
SPECIALCONTENT_DLP_CHILD = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_CardType { CARD_CTR = 0, CARD_TWL = 1, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_Action { FS_ACTION_UNKNOWN = 0, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_ArchiveAction {
ARCHIVE_ACTION_COMMIT_SAVE_DATA = 0,
ARCHIVE_ACTION_GET_TIMESTAMP = 1,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_SecureSaveAction {
SECURESAVE_ACTION_DELETE = 0,
SECURESAVE_ACTION_FORMAT = 1,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_FileAction { FILE_ACTION_UNKNOWN = 0, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum FS_DirectoryAction { DIRECTORY_ACTION_UNKNOWN = 0, }
#[repr(C)]
#[derive(Copy)]
pub struct FS_DirectoryEntry {
pub name: [u16_; 262usize],
pub shortName: [::libc::c_char; 10usize],
pub shortExt: [::libc::c_char; 4usize],
pub valid: u8_,
pub reserved: u8_,
pub attributes: u32_,
pub fileSize: u64_,
}
impl ::core::clone::Clone for FS_DirectoryEntry {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for FS_DirectoryEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_ArchiveResource {
pub sectorSize: u32_,
pub clusterSize: u32_,
pub totalClusters: u32_,
pub freeClusters: u32_,
}
impl ::core::default::Default for FS_ArchiveResource {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_ProgramInfo {
pub programId: u64_,
pub _bindgen_bitfield_1_: FS_MediaType,
pub padding: [u8_; 7usize],
}
impl ::core::default::Default for FS_ProgramInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_ProductInfo {
pub productCode: [::libc::c_char; 16usize],
pub companyCode: [::libc::c_char; 2usize],
pub remasterVersion: u16_,
}
impl ::core::default::Default for FS_ProductInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct FS_IntegrityVerificationSeed {
pub aesCbcMac: [u8_; 16usize],
pub movableSed: [u8_; 288usize],
}
impl ::core::clone::Clone for FS_IntegrityVerificationSeed {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for FS_IntegrityVerificationSeed {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_ExtSaveDataInfo {
pub _bindgen_bitfield_1_: FS_MediaType,
pub unknown: u8_,
pub reserved1: u16_,
pub saveId: u64_,
pub reserved2: u32_,
}
impl ::core::default::Default for FS_ExtSaveDataInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_SystemSaveDataInfo {
pub _bindgen_bitfield_1_: FS_MediaType,
pub unknown: u8_,
pub reserved: u16_,
pub saveId: u32_,
}
impl ::core::default::Default for FS_SystemSaveDataInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_DeviceMoveContext {
pub ivs: [u8_; 16usize],
pub encryptParameter: [u8_; 16usize],
}
impl ::core::default::Default for FS_DeviceMoveContext {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct FS_Path {
pub type_: FS_PathType,
pub size: u32_,
pub data: *const ::libc::c_void,
}
impl ::core::default::Default for FS_Path {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type FS_Archive = u64_;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct romfs_header {
pub headerSize: u32_,
pub dirHashTableOff: u32_,
pub dirHashTableSize: u32_,
pub dirTableOff: u32_,
pub dirTableSize: u32_,
pub fileHashTableOff: u32_,
pub fileHashTableSize: u32_,
pub fileTableOff: u32_,
pub fileTableSize: u32_,
pub fileDataOff: u32_,
}
impl ::core::default::Default for romfs_header {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct romfs_dir {
pub parent: u32_,
pub sibling: u32_,
pub childDir: u32_,
pub childFile: u32_,
pub nextHash: u32_,
pub nameLen: u32_,
pub name: [u16_; 0usize],
}
impl ::core::default::Default for romfs_dir {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct romfs_file {
pub parent: u32_,
pub sibling: u32_,
pub dataOff: u64_,
pub dataSize: u64_,
pub nextHash: u32_,
pub nameLen: u32_,
pub name: [u16_; 0usize],
}
impl ::core::default::Default for romfs_file {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub enum romfs_mount { }
extern "C" {
pub fn fsInit() -> Result;
pub fn fsExit();
pub fn fsUseSession(session: Handle);
pub fn fsEndUseSession();
pub fn fsExemptFromSession(archive: FS_Archive);
pub fn fsUnexemptFromSession(archive: FS_Archive);
pub fn fsMakePath(type_: FS_PathType, path: *const ::libc::c_void)
-> FS_Path;
pub fn fsGetSessionHandle() -> *mut Handle;
pub fn FSUSER_Control(action: FS_Action, input: *mut ::libc::c_void,
inputSize: u32_, output: *mut ::libc::c_void,
outputSize: u32_) -> Result;
pub fn FSUSER_Initialize(session: Handle) -> Result;
pub fn FSUSER_OpenFile(out: *mut Handle, archive: FS_Archive,
path: FS_Path, openFlags: u32_, attributes: u32_)
-> Result;
pub fn FSUSER_OpenFileDirectly(out: *mut Handle, archiveId: FS_ArchiveID,
archivePath: FS_Path, filePath: FS_Path,
openFlags: u32_, attributes: u32_)
-> Result;
pub fn FSUSER_DeleteFile(archive: FS_Archive, path: FS_Path) -> Result;
pub fn FSUSER_RenameFile(srcArchive: FS_Archive, srcPath: FS_Path,
dstArchive: FS_Archive, dstPath: FS_Path)
-> Result;
pub fn FSUSER_DeleteDirectory(archive: FS_Archive, path: FS_Path)
-> Result;
pub fn FSUSER_DeleteDirectoryRecursively(archive: FS_Archive,
path: FS_Path) -> Result;
pub fn FSUSER_CreateFile(archive: FS_Archive, path: FS_Path,
attributes: u32_, fileSize: u64_) -> Result;
pub fn FSUSER_CreateDirectory(archive: FS_Archive, path: FS_Path,
attributes: u32_) -> Result;
pub fn FSUSER_RenameDirectory(srcArchive: FS_Archive, srcPath: FS_Path,
dstArchive: FS_Archive, dstPath: FS_Path)
-> Result;
pub fn FSUSER_OpenDirectory(out: *mut Handle, archive: FS_Archive,
path: FS_Path) -> Result;
pub fn FSUSER_OpenArchive(archive: *mut FS_Archive, id: FS_ArchiveID,
path: FS_Path) -> Result;
pub fn FSUSER_ControlArchive(archive: FS_Archive,
action: FS_ArchiveAction,
input: *mut ::libc::c_void, inputSize: u32_,
output: *mut ::libc::c_void,
outputSize: u32_) -> Result;
pub fn FSUSER_CloseArchive(archive: FS_Archive) -> Result;
pub fn FSUSER_GetFreeBytes(freeBytes: *mut u64_, archive: FS_Archive)
-> Result;
pub fn FSUSER_GetCardType(type_: *mut FS_CardType) -> Result;
pub fn FSUSER_GetSdmcArchiveResource(archiveResource:
*mut FS_ArchiveResource)
-> Result;
pub fn FSUSER_GetNandArchiveResource(archiveResource:
*mut FS_ArchiveResource)
-> Result;
pub fn FSUSER_GetSdmcFatfsError(error: *mut u32_) -> Result;
pub fn FSUSER_IsSdmcDetected(detected: *mut u8) -> Result;
pub fn FSUSER_IsSdmcWritable(writable: *mut u8) -> Result;
pub fn FSUSER_GetSdmcCid(out: *mut u8_, length: u32_) -> Result;
pub fn FSUSER_GetNandCid(out: *mut u8_, length: u32_) -> Result;
pub fn FSUSER_GetSdmcSpeedInfo(speedInfo: *mut u32_) -> Result;
pub fn FSUSER_GetNandSpeedInfo(speedInfo: *mut u32_) -> Result;
pub fn FSUSER_GetSdmcLog(out: *mut u8_, length: u32_) -> Result;
pub fn FSUSER_GetNandLog(out: *mut u8_, length: u32_) -> Result;
pub fn FSUSER_ClearSdmcLog() -> Result;
pub fn FSUSER_ClearNandLog() -> Result;
pub fn FSUSER_CardSlotIsInserted(inserted: *mut u8) -> Result;
pub fn FSUSER_CardSlotPowerOn(status: *mut u8) -> Result;
pub fn FSUSER_CardSlotPowerOff(status: *mut u8) -> Result;
pub fn FSUSER_CardSlotGetCardIFPowerStatus(status: *mut u8) -> Result;
pub fn FSUSER_CardNorDirectCommand(commandId: u8_) -> Result;
pub fn FSUSER_CardNorDirectCommandWithAddress(commandId: u8_,
address: u32_) -> Result;
pub fn FSUSER_CardNorDirectRead(commandId: u8_, size: u32_,
output: *mut u8_) -> Result;
pub fn FSUSER_CardNorDirectReadWithAddress(commandId: u8_, address: u32_,
size: u32_, output: *mut u8_)
-> Result;
pub fn FSUSER_CardNorDirectWrite(commandId: u8_, size: u32_,
input: *mut u8_) -> Result;
pub fn FSUSER_CardNorDirectWriteWithAddress(commandId: u8_, address: u32_,
size: u32_, input: *mut u8_)
-> Result;
pub fn FSUSER_CardNorDirectRead_4xIO(commandId: u8_, address: u32_,
size: u32_, output: *mut u8_)
-> Result;
pub fn FSUSER_CardNorDirectCpuWriteWithoutVerify(address: u32_,
size: u32_,
input: *mut u8_)
-> Result;
pub fn FSUSER_CardNorDirectSectorEraseWithoutVerify(address: u32_)
-> Result;
pub fn FSUSER_GetProductInfo(info: *mut FS_ProductInfo, processId: u32_)
-> Result;
pub fn FSUSER_GetProgramLaunchInfo(info: *mut FS_ProgramInfo,
processId: u32_) -> Result;
pub fn FSUSER_SetCardSpiBaudRate(baudRate: FS_CardSpiBaudRate) -> Result;
pub fn FSUSER_SetCardSpiBusMode(busMode: FS_CardSpiBusMode) -> Result;
pub fn FSUSER_SendInitializeInfoTo9() -> Result;
pub fn FSUSER_GetSpecialContentIndex(index: *mut u16_,
mediaType: FS_MediaType,
programId: u64_,
type_: FS_SpecialContentType)
-> Result;
pub fn FSUSER_GetLegacyRomHeader(mediaType: FS_MediaType, programId: u64_,
header: *mut u8_) -> Result;
pub fn FSUSER_GetLegacyBannerData(mediaType: FS_MediaType,
programId: u64_, banner: *mut u8_)
-> Result;
pub fn FSUSER_CheckAuthorityToAccessExtSaveData(access: *mut u8,
mediaType: FS_MediaType,
saveId: u64_,
processId: u32_)
-> Result;
pub fn FSUSER_QueryTotalQuotaSize(quotaSize: *mut u64_, directories: u32_,
files: u32_, fileSizeCount: u32_,
fileSizes: *mut u64_) -> Result;
pub fn FSUSER_AbnegateAccessRight(accessRight: u32_) -> Result;
pub fn FSUSER_DeleteSdmcRoot() -> Result;
pub fn FSUSER_DeleteAllExtSaveDataOnNand() -> Result;
pub fn FSUSER_InitializeCtrFileSystem() -> Result;
pub fn FSUSER_CreateSeed() -> Result;
pub fn FSUSER_GetFormatInfo(totalSize: *mut u32_, directories: *mut u32_,
files: *mut u32_, duplicateData: *mut u8,
archiveId: FS_ArchiveID, path: FS_Path)
-> Result;
pub fn FSUSER_GetLegacyRomHeader2(headerSize: u32_,
mediaType: FS_MediaType,
programId: u64_, header: *mut u8_)
-> Result;
pub fn FSUSER_GetSdmcCtrRootPath(out: *mut u8_, length: u32_) -> Result;
pub fn FSUSER_GetArchiveResource(archiveResource: *mut FS_ArchiveResource,
mediaType: FS_SystemMediaType) -> Result;
pub fn FSUSER_ExportIntegrityVerificationSeed(seed:
*mut FS_IntegrityVerificationSeed)
-> Result;
pub fn FSUSER_ImportIntegrityVerificationSeed(seed:
*mut FS_IntegrityVerificationSeed)
-> Result;
pub fn FSUSER_FormatSaveData(archiveId: FS_ArchiveID, path: FS_Path,
blocks: u32_, directories: u32_, files: u32_,
directoryBuckets: u32_, fileBuckets: u32_,
duplicateData: u8) -> Result;
pub fn FSUSER_GetLegacySubBannerData(bannerSize: u32_,
mediaType: FS_MediaType,
programId: u64_, banner: *mut u8_)
-> Result;
pub fn FSUSER_UpdateSha256Context(data: *const ::libc::c_void,
inputSize: u32_, hash: *mut u8_)
-> Result;
pub fn FSUSER_ReadSpecialFile(bytesRead: *mut u32_, fileOffset: u64_,
size: u32_, data: *mut u8_) -> Result;
pub fn FSUSER_GetSpecialFileSize(fileSize: *mut u64_) -> Result;
pub fn FSUSER_CreateExtSaveData(info: FS_ExtSaveDataInfo,
directories: u32_, files: u32_,
sizeLimit: u64_, smdhSize: u32_,
smdh: *mut u8_) -> Result;
pub fn FSUSER_DeleteExtSaveData(info: FS_ExtSaveDataInfo) -> Result;
pub fn FSUSER_ReadExtSaveDataIcon(bytesRead: *mut u32_,
info: FS_ExtSaveDataInfo,
smdhSize: u32_, smdh: *mut u8_)
-> Result;
pub fn FSUSER_GetExtDataBlockSize(totalBlocks: *mut u64_,
freeBlocks: *mut u64_,
blockSize: *mut u32_,
info: FS_ExtSaveDataInfo) -> Result;
pub fn FSUSER_EnumerateExtSaveData(idsWritten: *mut u32_, idsSize: u32_,
mediaType: FS_MediaType, idSize: u32_,
shared: u8, ids: *mut u8_) -> Result;
pub fn FSUSER_CreateSystemSaveData(info: FS_SystemSaveDataInfo,
totalSize: u32_, blockSize: u32_,
directories: u32_, files: u32_,
directoryBuckets: u32_,
fileBuckets: u32_, duplicateData: u8)
-> Result;
pub fn FSUSER_DeleteSystemSaveData(info: FS_SystemSaveDataInfo) -> Result;
pub fn FSUSER_StartDeviceMoveAsSource(context: *mut FS_DeviceMoveContext)
-> Result;
pub fn FSUSER_StartDeviceMoveAsDestination(context: FS_DeviceMoveContext,
clear: u8) -> Result;
pub fn FSUSER_SetArchivePriority(archive: FS_Archive, priority: u32_)
-> Result;
pub fn FSUSER_GetArchivePriority(priority: *mut u32_, archive: FS_Archive)
-> Result;
pub fn FSUSER_SetCtrCardLatencyParameter(latency: u64_,
emulateEndurance: u8) -> Result;
pub fn FSUSER_SwitchCleanupInvalidSaveData(enable: u8) -> Result;
pub fn FSUSER_EnumerateSystemSaveData(idsWritten: *mut u32_,
idsSize: u32_, ids: *mut u32_)
-> Result;
pub fn FSUSER_InitializeWithSdkVersion(session: Handle, version: u32_)
-> Result;
pub fn FSUSER_SetPriority(priority: u32_) -> Result;
pub fn FSUSER_GetPriority(priority: *mut u32_) -> Result;
pub fn FSUSER_SetSaveDataSecureValue(value: u64_,
slot: FS_SecureValueSlot,
titleUniqueId: u32_,
titleVariation: u8_) -> Result;
pub fn FSUSER_GetSaveDataSecureValue(exists: *mut u8, value: *mut u64_,
slot: FS_SecureValueSlot,
titleUniqueId: u32_,
titleVariation: u8_) -> Result;
pub fn FSUSER_ControlSecureSave(action: FS_SecureSaveAction,
input: *mut ::libc::c_void,
inputSize: u32_,
output: *mut ::libc::c_void,
outputSize: u32_) -> Result;
pub fn FSUSER_GetMediaType(mediaType: *mut FS_MediaType) -> Result;
pub fn FSFILE_Control(handle: Handle, action: FS_FileAction,
input: *mut ::libc::c_void, inputSize: u32_,
output: *mut ::libc::c_void, outputSize: u32_)
-> Result;
pub fn FSFILE_OpenSubFile(handle: Handle, subFile: *mut Handle,
offset: u64_, size: u64_) -> Result;
pub fn FSFILE_Read(handle: Handle, bytesRead: *mut u32_, offset: u64_,
buffer: *mut ::libc::c_void, size: u32_) -> Result;
pub fn FSFILE_Write(handle: Handle, bytesWritten: *mut u32_, offset: u64_,
buffer: *const ::libc::c_void, size: u32_,
flags: u32_) -> Result;
pub fn FSFILE_GetSize(handle: Handle, size: *mut u64_) -> Result;
pub fn FSFILE_SetSize(handle: Handle, size: u64_) -> Result;
pub fn FSFILE_GetAttributes(handle: Handle, attributes: *mut u32_)
-> Result;
pub fn FSFILE_SetAttributes(handle: Handle, attributes: u32_) -> Result;
pub fn FSFILE_Close(handle: Handle) -> Result;
pub fn FSFILE_Flush(handle: Handle) -> Result;
pub fn FSFILE_SetPriority(handle: Handle, priority: u32_) -> Result;
pub fn FSFILE_GetPriority(handle: Handle, priority: *mut u32_) -> Result;
pub fn FSFILE_OpenLinkFile(handle: Handle, linkFile: *mut Handle)
-> Result;
pub fn FSDIR_Control(handle: Handle, action: FS_DirectoryAction,
input: *mut ::libc::c_void, inputSize: u32_,
output: *mut ::libc::c_void, outputSize: u32_)
-> Result;
pub fn FSDIR_Read(handle: Handle, entriesRead: *mut u32_,
entryCount: u32_, entries: *mut FS_DirectoryEntry)
-> Result;
pub fn FSDIR_Close(handle: Handle) -> Result;
pub fn FSDIR_SetPriority(handle: Handle, priority: u32_) -> Result;
pub fn FSDIR_GetPriority(handle: Handle, priority: *mut u32_) -> Result;
pub fn romfsMount(mount: *mut *mut romfs_mount) -> Result;
pub fn romfsMountFromFile(file: Handle, offset: u32_,
mount: *mut *mut romfs_mount) -> Result;
pub fn romfsBind(mount: *mut romfs_mount) -> Result;
pub fn romfsUnmount(mount: *mut romfs_mount) -> Result;
}
use ::types::*;

107
ctru-sys/src/services/gspgpu.rs
Unescape View File

@ -1,107 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct GSPGPU_FramebufferInfo {
pub active_framebuf: u32_,
pub framebuf0_vaddr: *mut u32_,
pub framebuf1_vaddr: *mut u32_,
pub framebuf_widthbytesize: u32_,
pub format: u32_,
pub framebuf_dispselect: u32_,
pub unk: u32_,
}
impl ::core::default::Default for GSPGPU_FramebufferInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum GSPGPU_FramebufferFormats {
GSP_RGBA8_OES = 0,
GSP_BGR8_OES = 1,
GSP_RGB565_OES = 2,
GSP_RGB5_A1_OES = 3,
GSP_RGBA4_OES = 4,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct GSPGPU_CaptureInfoEntry {
pub framebuf0_vaddr: *mut u32_,
pub framebuf1_vaddr: *mut u32_,
pub format: u32_,
pub framebuf_widthbytesize: u32_,
}
impl ::core::default::Default for GSPGPU_CaptureInfoEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct GSPGPU_CaptureInfo {
pub screencapture: [GSPGPU_CaptureInfoEntry; 2usize],
}
impl ::core::default::Default for GSPGPU_CaptureInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum GSPGPU_Event {
GSPGPU_EVENT_PSC0 = 0,
GSPGPU_EVENT_PSC1 = 1,
GSPGPU_EVENT_VBlank0 = 2,
GSPGPU_EVENT_VBlank1 = 3,
GSPGPU_EVENT_PPF = 4,
GSPGPU_EVENT_P3D = 5,
GSPGPU_EVENT_DMA = 6,
GSPGPU_EVENT_MAX = 7,
}
extern "C" {
pub fn gspInit() -> Result;
pub fn gspExit();
pub fn gspSetEventCallback(id: GSPGPU_Event, cb: ThreadFunc,
data: *mut ::libc::c_void, oneShot: u8);
pub fn gspInitEventHandler(gspEvent: Handle, gspSharedMem: *mut vu8,
gspThreadId: u8_) -> Result;
pub fn gspExitEventHandler();
pub fn gspWaitForEvent(id: GSPGPU_Event, nextEvent: u8);
pub fn gspWaitForAnyEvent() -> GSPGPU_Event;
pub fn gspSubmitGxCommand(sharedGspCmdBuf: *mut u32_,
gxCommand: *mut u32_) -> Result;
pub fn GSPGPU_AcquireRight(flags: u8_) -> Result;
pub fn GSPGPU_ReleaseRight() -> Result;
pub fn GSPGPU_ImportDisplayCaptureInfo(captureinfo:
*mut GSPGPU_CaptureInfo)
-> Result;
pub fn GSPGPU_SaveVramSysArea() -> Result;
pub fn GSPGPU_RestoreVramSysArea() -> Result;
pub fn GSPGPU_SetLcdForceBlack(flags: u8_) -> Result;
pub fn GSPGPU_SetBufferSwap(screenid: u32_,
framebufinfo: *mut GSPGPU_FramebufferInfo)
-> Result;
pub fn GSPGPU_FlushDataCache(adr: *const ::libc::c_void, size: u32_)
-> Result;
pub fn GSPGPU_InvalidateDataCache(adr: *const ::libc::c_void, size: u32_)
-> Result;
pub fn GSPGPU_WriteHWRegs(regAddr: u32_, data: *mut u32_, size: u8_)
-> Result;
pub fn GSPGPU_WriteHWRegsWithMask(regAddr: u32_, data: *mut u32_,
datasize: u8_, maskdata: *mut u32_,
masksize: u8_) -> Result;
pub fn GSPGPU_ReadHWRegs(regAddr: u32_, data: *mut u32_, size: u8_)
-> Result;
pub fn GSPGPU_RegisterInterruptRelayQueue(eventHandle: Handle,
flags: u32_,
outMemHandle: *mut Handle,
threadID: *mut u8_) -> Result;
pub fn GSPGPU_UnregisterInterruptRelayQueue() -> Result;
pub fn GSPGPU_TriggerCmdReqQueue() -> Result;
}
use ::types::*;

22
ctru-sys/src/services/gsplcd.rs
Unescape View File

@ -1,22 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
GSPLCD_SCREEN_TOP = 1,
GSPLCD_SCREEN_BOTTOM = 2,
GSPLCD_SCREEN_BOTH = 3,
}
extern "C" {
pub fn gspLcdInit() -> Result;
pub fn gspLcdExit();
pub fn GSPLCD_PowerOnBacklight(screen: u32_) -> Result;
pub fn GSPLCD_PowerOffBacklight(screen: u32_) -> Result;
pub fn GSPLCD_GetVendors(vendors: *mut u8_) -> Result;
}
use ::types::*;

119
ctru-sys/src/services/hid.rs
Unescape View File

@ -1,119 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum PAD_KEY {
KEY_A = 1,
KEY_B = 2,
KEY_SELECT = 4,
KEY_START = 8,
KEY_DRIGHT = 16,
KEY_DLEFT = 32,
KEY_DUP = 64,
KEY_DDOWN = 128,
KEY_R = 256,
KEY_L = 512,
KEY_X = 1024,
KEY_Y = 2048,
KEY_ZL = 16384,
KEY_ZR = 32768,
KEY_TOUCH = 1048576,
KEY_CSTICK_RIGHT = 16777216,
KEY_CSTICK_LEFT = 33554432,
KEY_CSTICK_UP = 67108864,
KEY_CSTICK_DOWN = 134217728,
KEY_CPAD_RIGHT = 268435456,
KEY_CPAD_LEFT = 536870912,
KEY_CPAD_UP = 1073741824,
KEY_CPAD_DOWN = 2147483648,
KEY_UP = 1073741888,
KEY_DOWN = 2147483776,
KEY_LEFT = 536870944,
KEY_RIGHT = 268435472,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct touchPosition {
pub px: u16_,
pub py: u16_,
}
impl ::core::default::Default for touchPosition {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct circlePosition {
pub dx: s16,
pub dy: s16,
}
impl ::core::default::Default for circlePosition {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct accelVector {
pub x: s16,
pub y: s16,
pub z: s16,
}
impl ::core::default::Default for accelVector {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct angularRate {
pub x: s16,
pub z: s16,
pub y: s16,
}
impl ::core::default::Default for angularRate {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum HID_Event {
HIDEVENT_PAD0 = 0,
HIDEVENT_PAD1 = 1,
HIDEVENT_Accel = 2,
HIDEVENT_Gyro = 3,
HIDEVENT_DebugPad = 4,
HIDEVENT_MAX = 5,
}
extern "C" {
pub static mut hidMemHandle: Handle;
pub static mut hidSharedMem: *mut vu32;
}
extern "C" {
pub fn hidInit() -> Result;
pub fn hidExit();
pub fn hidScanInput();
pub fn hidKeysHeld() -> u32_;
pub fn hidKeysDown() -> u32_;
pub fn hidKeysUp() -> u32_;
pub fn hidTouchRead(pos: *mut touchPosition);
pub fn hidCircleRead(pos: *mut circlePosition);
pub fn hidAccelRead(vector: *mut accelVector);
pub fn hidGyroRead(rate: *mut angularRate);
pub fn hidWaitForEvent(id: HID_Event, nextEvent: u8);
pub fn HIDUSER_GetHandles(outMemHandle: *mut Handle,
eventpad0: *mut Handle, eventpad1: *mut Handle,
eventaccel: *mut Handle, eventgyro: *mut Handle,
eventdebugpad: *mut Handle) -> Result;
pub fn HIDUSER_EnableAccelerometer() -> Result;
pub fn HIDUSER_DisableAccelerometer() -> Result;
pub fn HIDUSER_EnableGyroscope() -> Result;
pub fn HIDUSER_DisableGyroscope() -> Result;
pub fn HIDUSER_GetGyroscopeRawToDpsCoefficient(coeff: *mut f32) -> Result;
pub fn HIDUSER_GetSoundVolume(volume: *mut u8_) -> Result;
}
use ::types::*;

126
ctru-sys/src/services/httpc.rs
Unescape View File

@ -1,126 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct httpcContext {
pub servhandle: Handle,
pub httphandle: u32_,
}
impl ::core::default::Default for httpcContext {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum HTTPC_RequestMethod {
HTTPC_METHOD_GET = 1,
HTTPC_METHOD_POST = 2,
HTTPC_METHOD_HEAD = 3,
HTTPC_METHOD_PUT = 4,
HTTPC_METHOD_DELETE = 5,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum HTTPC_RequestStatus {
HTTPC_STATUS_REQUEST_IN_PROGRESS = 5,
HTTPC_STATUS_DOWNLOAD_READY = 7,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum HTTPC_KeepAlive {
HTTPC_KEEPALIVE_DISABLED = 0,
HTTPC_KEEPALIVE_ENABLED = 1,
}
extern "C" {
pub fn httpcInit(sharedmem_size: u32_) -> Result;
pub fn httpcExit();
pub fn httpcOpenContext(context: *mut httpcContext,
method: HTTPC_RequestMethod,
url: *const ::libc::c_char,
use_defaultproxy: u32_) -> Result;
pub fn httpcCloseContext(context: *mut httpcContext) -> Result;
pub fn httpcCancelConnection(context: *mut httpcContext) -> Result;
pub fn httpcAddRequestHeaderField(context: *mut httpcContext,
name: *const ::libc::c_char,
value: *const ::libc::c_char) -> Result;
pub fn httpcAddPostDataAscii(context: *mut httpcContext,
name: *const ::libc::c_char,
value: *const ::libc::c_char) -> Result;
pub fn httpcAddPostDataRaw(context: *mut httpcContext, data: *const u32_,
len: u32_) -> Result;
pub fn httpcBeginRequest(context: *mut httpcContext) -> Result;
pub fn httpcReceiveData(context: *mut httpcContext, buffer: *mut u8_,
size: u32_) -> Result;
pub fn httpcReceiveDataTimeout(context: *mut httpcContext,
buffer: *mut u8_, size: u32_,
timeout: u64_) -> Result;
pub fn httpcGetRequestState(context: *mut httpcContext,
out: *mut HTTPC_RequestStatus) -> Result;
pub fn httpcGetDownloadSizeState(context: *mut httpcContext,
downloadedsize: *mut u32_,
contentsize: *mut u32_) -> Result;
pub fn httpcGetResponseStatusCode(context: *mut httpcContext,
out: *mut u32_) -> Result;
pub fn httpcGetResponseStatusCodeTimeout(context: *mut httpcContext,
out: *mut u32_, timeout: u64_)
-> Result;
pub fn httpcGetResponseHeader(context: *mut httpcContext,
name: *const ::libc::c_char,
value: *mut ::libc::c_char,
valuebuf_maxsize: u32_) -> Result;
pub fn httpcAddTrustedRootCA(context: *mut httpcContext, cert: *const u8_,
certsize: u32_) -> Result;
pub fn httpcAddDefaultCert(context: *mut httpcContext,
certID: SSLC_DefaultRootCert) -> Result;
pub fn httpcSelectRootCertChain(context: *mut httpcContext,
RootCertChain_contexthandle: u32_)
-> Result;
pub fn httpcSetClientCert(context: *mut httpcContext, cert: *const u8_,
certsize: u32_, privk: *const u8_,
privk_size: u32_) -> Result;
pub fn httpcSetClientCertDefault(context: *mut httpcContext,
certID: SSLC_DefaultClientCert)
-> Result;
pub fn httpcSetClientCertContext(context: *mut httpcContext,
ClientCert_contexthandle: u32_)
-> Result;
pub fn httpcSetSSLOpt(context: *mut httpcContext, options: u32_)
-> Result;
pub fn httpcSetSSLClearOpt(context: *mut httpcContext, options: u32_)
-> Result;
pub fn httpcCreateRootCertChain(RootCertChain_contexthandle: *mut u32_)
-> Result;
pub fn httpcDestroyRootCertChain(RootCertChain_contexthandle: u32_)
-> Result;
pub fn httpcRootCertChainAddCert(RootCertChain_contexthandle: u32_,
cert: *const u8_, certsize: u32_,
cert_contexthandle: *mut u32_) -> Result;
pub fn httpcRootCertChainAddDefaultCert(RootCertChain_contexthandle: u32_,
certID: SSLC_DefaultRootCert,
cert_contexthandle: *mut u32_)
-> Result;
pub fn httpcRootCertChainRemoveCert(RootCertChain_contexthandle: u32_,
cert_contexthandle: u32_) -> Result;
pub fn httpcOpenClientCertContext(cert: *const u8_, certsize: u32_,
privk: *const u8_, privk_size: u32_,
ClientCert_contexthandle: *mut u32_)
-> Result;
pub fn httpcOpenDefaultClientCertContext(certID: SSLC_DefaultClientCert,
ClientCert_contexthandle:
*mut u32_) -> Result;
pub fn httpcCloseClientCertContext(ClientCert_contexthandle: u32_)
-> Result;
pub fn httpcDownloadData(context: *mut httpcContext, buffer: *mut u8_,
size: u32_, downloadedsize: *mut u32_) -> Result;
pub fn httpcSetKeepAlive(context: *mut httpcContext,
option: HTTPC_KeepAlive) -> Result;
}
use ::types::*;
use super::sslc::*;

25
ctru-sys/src/services/ir.rs
Unescape View File

@ -1,25 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn iruInit(sharedmem_addr: *mut u32_, sharedmem_size: u32_) -> Result;
pub fn iruExit();
pub fn iruGetServHandle() -> Handle;
pub fn iruSendData(buf: *mut u8_, size: u32_, wait: u8) -> Result;
pub fn iruRecvData(buf: *mut u8_, size: u32_, flag: u8_,
transfercount: *mut u32_, wait: u8) -> Result;
pub fn IRU_Initialize() -> Result;
pub fn IRU_Shutdown() -> Result;
pub fn IRU_StartSendTransfer(buf: *mut u8_, size: u32_) -> Result;
pub fn IRU_WaitSendTransfer() -> Result;
pub fn IRU_StartRecvTransfer(size: u32_, flag: u8_) -> Result;
pub fn IRU_WaitRecvTransfer(transfercount: *mut u32_) -> Result;
pub fn IRU_SetBitRate(value: u8_) -> Result;
pub fn IRU_GetBitRate(out: *mut u8_) -> Result;
pub fn IRU_SetIRLEDState(value: u32_) -> Result;
pub fn IRU_GetIRLEDRecvState(out: *mut u32_) -> Result;
}
use ::types::*;

24
ctru-sys/src/services/irrst.rs
Unescape View File

@ -1,24 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub static mut irrstMemHandle: Handle;
pub static mut irrstSharedMem: *mut vu32;
}
extern "C" {
pub fn irrstInit() -> Result;
pub fn irrstExit();
pub fn irrstScanInput();
pub fn irrstKeysHeld() -> u32_;
pub fn irrstCstickRead(pos: *mut circlePosition);
pub fn irrstWaitForEvent(nextEvent: u8);
pub fn IRRST_GetHandles(outMemHandle: *mut Handle,
outEventHandle: *mut Handle) -> Result;
pub fn IRRST_Initialize(unk1: u32_, unk2: u8_) -> Result;
pub fn IRRST_Shutdown() -> Result;
}
use ::types::*;
use super::hid::*;

47
ctru-sys/src/services/mic.rs
Unescape View File

@ -1,47 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum MICU_Encoding {
MICU_ENCODING_PCM8 = 0,
MICU_ENCODING_PCM16 = 1,
MICU_ENCODING_PCM8_SIGNED = 2,
MICU_ENCODING_PCM16_SIGNED = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum MICU_SampleRate {
MICU_SAMPLE_RATE_32730 = 0,
MICU_SAMPLE_RATE_16360 = 1,
MICU_SAMPLE_RATE_10910 = 2,
MICU_SAMPLE_RATE_8180 = 3,
}
extern "C" {
pub fn micInit(buffer: *mut u8_, bufferSize: u32_) -> Result;
pub fn micExit();
pub fn micGetSampleDataSize() -> u32_;
pub fn micGetLastSampleOffset() -> u32_;
pub fn MICU_MapSharedMem(size: u32_, handle: Handle) -> Result;
pub fn MICU_UnmapSharedMem() -> Result;
pub fn MICU_StartSampling(encoding: MICU_Encoding,
sampleRate: MICU_SampleRate, offset: u32_,
size: u32_, loop_: u8) -> Result;
pub fn MICU_AdjustSampling(sampleRate: MICU_SampleRate) -> Result;
pub fn MICU_StopSampling() -> Result;
pub fn MICU_IsSampling(sampling: *mut u8) -> Result;
pub fn MICU_GetEventHandle(handle: *mut Handle) -> Result;
pub fn MICU_SetGain(gain: u8_) -> Result;
pub fn MICU_GetGain(gain: *mut u8_) -> Result;
pub fn MICU_SetPower(power: u8) -> Result;
pub fn MICU_GetPower(power: *mut u8) -> Result;
pub fn MICU_SetClamp(clamp: u8) -> Result;
pub fn MICU_GetClamp(clamp: *mut u8) -> Result;
pub fn MICU_SetAllowShellClosed(allowShellClosed: u8) -> Result;
}
use ::types::*;

31
ctru-sys/src/services/mod.rs
Unescape View File

@ -1,31 +0,0 @@
pub mod ac;
pub mod am;
pub mod ampxi;
pub mod apt;
pub mod cam;
pub mod cfgnor;
pub mod cfgu;
pub mod dsp;
pub mod fs;
pub mod gspgpu;
pub mod gsplcd;
pub mod hid;
pub mod httpc;
pub mod ir;
pub mod irrst;
pub mod mic;
pub mod mvd;
pub mod ndm;
pub mod news;
pub mod nfc;
pub mod ns;
pub mod pm;
pub mod ps;
pub mod ptmsysm;
pub mod ptmu;
pub mod pxidev;
pub mod qtm;
pub mod srvpm;
pub mod sslc;
pub mod uds;
pub mod y2r;

0
ctru-sys/src/services/mvd.rs
Unescape View File

23
ctru-sys/src/services/ndm.rs
Unescape View File

@ -1,23 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum NDM_ExclusiveState {
EXCLUSIVE_STATE_NONE = 0,
EXCLUSIVE_STATE_INFRASTRUCTURE = 1,
EXCLUSIVE_STATE_LOCAL_COMMUNICATIONS = 2,
EXCLUSIVE_STATE_STREETPASS = 3,
EXCLUSIVE_STATE_STREETPASS_DATA = 4,
}
extern "C" {
pub fn ndmuInit() -> Result;
pub fn ndmuExit();
pub fn ndmuEnterExclusiveState(state: NDM_ExclusiveState) -> Result;
pub fn ndmuLeaveExclusiveState() -> Result;
}
use ::types::*;

52
ctru-sys/src/services/news.rs
Unescape View File

@ -1,52 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct NotificationHeader {
pub dataSet: u8,
pub unread: u8,
pub enableJPEG: u8,
pub isSpotPass: u8,
pub isOptedOut: u8,
pub unkData: [u8_; 3usize],
pub processID: u64_,
pub unkData2: [u8_; 8usize],
pub jumpParam: u64_,
pub unkData3: [u8_; 8usize],
pub time: u64_,
pub title: [u16_; 32usize],
}
impl ::core::default::Default for NotificationHeader {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn newsInit() -> Result;
pub fn newsExit();
pub fn NEWS_AddNotification(title: *const u16_, titleLength: u32_,
message: *const u16_, messageLength: u32_,
imageData: *const ::libc::c_void,
imageSize: u32_, jpeg: u8) -> Result;
pub fn NEWS_GetTotalNotifications(num: *mut u32_) -> Result;
pub fn NEWS_SetNotificationHeader(news_id: u32_,
header: *const NotificationHeader)
-> Result;
pub fn NEWS_GetNotificationHeader(news_id: u32_,
header: *mut NotificationHeader)
-> Result;
pub fn NEWS_SetNotificationMessage(news_id: u32_, message: *const u16_,
size: u32_) -> Result;
pub fn NEWS_GetNotificationMessage(news_id: u32_, message: *mut u16_,
size: *mut u32_) -> Result;
pub fn NEWS_SetNotificationImage(news_id: u32_,
buffer: *const ::libc::c_void,
size: u32_) -> Result;
pub fn NEWS_GetNotificationImage(news_id: u32_,
buffer: *mut ::libc::c_void,
size: *mut u32_) -> Result;
}
use ::types::*;

127
ctru-sys/src/services/nfc.rs
Unescape View File

@ -1,127 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum NFC_OpType { NFC_OpType_1 = 1, NFC_OpType_NFCTag = 2, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum NFC_TagState {
NFC_TagState_Uninitialized = 0,
NFC_TagState_ScanningStopped = 1,
NFC_TagState_Scanning = 2,
NFC_TagState_InRange = 3,
NFC_TagState_OutOfRange = 4,
NFC_TagState_DataReady = 5,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
NFC_amiiboFlag_Setup = 16,
NFC_amiiboFlag_AppDataSetup = 32,
}
#[repr(C)]
#[derive(Copy)]
pub struct NFC_TagInfo {
pub id_offset_size: u16_,
pub unk_x2: u8_,
pub unk_x3: u8_,
pub id: [u8_; 40usize],
}
impl ::core::clone::Clone for NFC_TagInfo {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for NFC_TagInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct NFC_AmiiboSettings {
pub mii: [u8_; 96usize],
pub nickname: [u16_; 11usize],
pub flags: u8_,
pub countrycodeid: u8_,
pub setupdate_year: u16_,
pub setupdate_month: u8_,
pub setupdate_day: u8_,
pub unk_x7c: [u8_; 44usize],
}
impl ::core::clone::Clone for NFC_AmiiboSettings {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for NFC_AmiiboSettings {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct NFC_AmiiboConfig {
pub lastwritedate_year: u16_,
pub lastwritedate_month: u8_,
pub lastwritedate_day: u8_,
pub write_counter: u16_,
pub val_x6: u16_,
pub val_x8: u8_,
pub val_x9: u8_,
pub val_xa: u16_,
pub val_xc: u8_,
pub pagex4_byte3: u8_,
pub appdata_size: u8_,
pub zeros: [u8_; 49usize],
}
impl ::core::clone::Clone for NFC_AmiiboConfig {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for NFC_AmiiboConfig {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct NFC_AppDataInitStruct {
pub data_x0: [u8_; 12usize],
pub data_xc: [u8_; 48usize],
}
impl ::core::clone::Clone for NFC_AppDataInitStruct {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for NFC_AppDataInitStruct {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct NFC_AppDataWriteStruct {
pub id: [u8_; 10usize],
pub id_size: u8_,
pub unused_xb: [u8_; 21usize],
}
impl ::core::default::Default for NFC_AppDataWriteStruct {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn nfcInit(type_: NFC_OpType) -> Result;
pub fn nfcExit();
pub fn nfcGetSessionHandle() -> Handle;
pub fn nfcStartScanning(inval: u16_) -> Result;
pub fn nfcStopScanning();
pub fn nfcLoadAmiiboData() -> Result;
pub fn nfcResetTagScanState() -> Result;
pub fn nfcUpdateStoredAmiiboData() -> Result;
pub fn nfcGetTagState(state: *mut NFC_TagState) -> Result;
pub fn nfcGetTagInfo(out: *mut NFC_TagInfo) -> Result;
pub fn nfcOpenAppData(amiibo_appid: u32_) -> Result;
pub fn nfcInitializeWriteAppData(amiibo_appid: u32_,
buf: *const ::libc::c_void, size: ::libc::size_t)
-> Result;
pub fn nfcReadAppData(buf: *mut ::libc::c_void, size: ::libc::size_t) -> Result;
pub fn nfcWriteAppData(buf: *const ::libc::c_void, size: ::libc::size_t,
taginfo: *mut NFC_TagInfo) -> Result;
pub fn nfcGetAmiiboSettings(out: *mut NFC_AmiiboSettings) -> Result;
pub fn nfcGetAmiiboConfig(out: *mut NFC_AmiiboConfig) -> Result;
}
use ::types::*;

17
ctru-sys/src/services/ns.rs
Unescape View File

@ -1,17 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn nsInit() -> Result;
pub fn nsExit();
pub fn NS_LaunchFIRM(titleid: u64_) -> Result;
pub fn NS_LaunchTitle(titleid: u64_, launch_flags: u32_,
procid: *mut u32_) -> Result;
pub fn NS_LaunchApplicationFIRM(titleid: u64_, flags: u32_) -> Result;
pub fn NS_RebootToTitle(mediatype: u8_, titleid: u64_) -> Result;
pub fn NS_TerminateProcessTID(titleid: u64_) -> Result;
}
use ::types::*;

19
ctru-sys/src/services/pm.rs
Unescape View File

@ -1,19 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn pmInit() -> Result;
pub fn pmExit();
pub fn PM_LaunchTitle(mediatype: u8_, titleid: u64_, launch_flags: u32_)
-> Result;
pub fn PM_GetTitleExheaderFlags(mediatype: u8_, titleid: u64_,
out: *mut u8_) -> Result;
pub fn PM_SetFIRMLaunchParams(size: u32_, in_: *mut u8_) -> Result;
pub fn PM_GetFIRMLaunchParams(size: u32_, out: *mut u8_) -> Result;
pub fn PM_LaunchFIRMSetParams(firm_titleid_low: u32_, size: u32_,
in_: *mut u8_) -> Result;
}
use ::types::*;

8
ctru-sys/src/services/pmtsym.rs
Unescape View File

@ -1,8 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
use ::types::*;

53
ctru-sys/src/services/ps.rs
Unescape View File

@ -1,53 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum PS_AESAlgorithm {
PS_ALGORITHM_CBC_ENC = 0,
PS_ALGORITHM_CBC_DEC = 1,
PS_ALGORITHM_CTR_ENC = 2,
PS_ALGORITHM_CTR_DEC = 3,
PS_ALGORITHM_CCM_ENC = 4,
PS_ALGORITHM_CCM_DEC = 5,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum PS_AESKeyType {
PS_KEYSLOT_0D = 0,
PS_KEYSLOT_2D = 1,
PS_KEYSLOT_31 = 2,
PS_KEYSLOT_38 = 3,
PS_KEYSLOT_32 = 4,
PS_KEYSLOT_39_DLP = 5,
PS_KEYSLOT_2E = 6,
PS_KEYSLOT_INVALID = 7,
PS_KEYSLOT_36 = 8,
PS_KEYSLOT_39_NFC = 9,
}
extern "C" {
pub fn psInit() -> Result;
pub fn psExit();
pub fn PS_EncryptDecryptAes(size: u32_, in_: *mut u8_, out: *mut u8_,
aes_algo: PS_AESAlgorithm,
key_type: PS_AESKeyType, iv: *mut u8_)
-> Result;
pub fn PS_EncryptSignDecryptVerifyAesCcm(in_: *mut u8_, in_size: u32_,
out: *mut u8_, out_size: u32_,
data_len: u32_,
mac_data_len: u32_,
mac_len: u32_,
aes_algo: PS_AESAlgorithm,
key_type: PS_AESKeyType,
nonce: *mut u8_) -> Result;
pub fn PS_GetLocalFriendCodeSeed(seed: *mut u64_) -> Result;
pub fn PS_GetDeviceId(device_id: *mut u32_) -> Result;
pub fn PS_GenerateRandomBytes(out: *mut ::libc::c_void, len: ::libc::size_t)
-> Result;
}
use ::types::*;

15
ctru-sys/src/services/ptmsym.rs
Unescape View File

@ -1,15 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn ptmSysmInit() -> Result;
pub fn ptmSysmExit();
pub fn PTMSYSM_CheckNew3DS() -> Result;
pub fn PTMSYSM_ConfigureNew3DSCPU(value: u8_) -> Result;
pub fn PTMSYSM_ShutdownAsync(timeout: u64_) -> Result;
pub fn PTMSYSM_RebootAsync(timeout: u64_) -> Result;
}
use ::types::*;

15
ctru-sys/src/services/ptmsysm.rs
Unescape View File

@ -1,15 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn ptmSysmInit() -> Result;
pub fn ptmSysmExit();
pub fn PTMSYSM_CheckNew3DS() -> Result;
pub fn PTMSYSM_ConfigureNew3DSCPU(value: u8_) -> Result;
pub fn PTMSYSM_ShutdownAsync(timeout: u64_) -> Result;
pub fn PTMSYSM_RebootAsync(timeout: u64_) -> Result;
}
use ::types::*;

16
ctru-sys/src/services/ptmu.rs
Unescape View File

@ -1,16 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn ptmuInit() -> Result;
pub fn ptmuExit();
pub fn PTMU_GetShellState(out: *mut u8_) -> Result;
pub fn PTMU_GetBatteryLevel(out: *mut u8_) -> Result;
pub fn PTMU_GetBatteryChargeState(out: *mut u8_) -> Result;
pub fn PTMU_GetPedometerState(out: *mut u8_) -> Result;
pub fn PTMU_GetTotalStepCount(steps: *mut u32_) -> Result;
}
use ::types::*;

50
ctru-sys/src/services/pxidev.rs
Unescape View File

@ -1,50 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum PXIDEV_WaitType {
WAIT_NONE = 0,
WAIT_SLEEP = 1,
WAIT_IREQ_RETURN = 2,
WAIT_IREQ_CONTINUE = 3,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum PXIDEV_DeassertType {
DEASSERT_NONE = 0,
DEASSERT_BEFORE_WAIT = 1,
DEASSERT_AFTER_WAIT = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct PXIDEV_SPIBuffer {
pub ptr: *mut ::libc::c_void,
pub size: u32_,
pub transferOption: u8_,
pub waitOperation: u64_,
}
impl ::core::default::Default for PXIDEV_SPIBuffer {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn pxiDevInit() -> Result;
pub fn pxiDevExit();
pub fn PXIDEV_SPIMultiWriteRead(header: *mut PXIDEV_SPIBuffer,
writeBuffer1: *mut PXIDEV_SPIBuffer,
readBuffer1: *mut PXIDEV_SPIBuffer,
writeBuffer2: *mut PXIDEV_SPIBuffer,
readBuffer2: *mut PXIDEV_SPIBuffer,
footer: *mut PXIDEV_SPIBuffer) -> Result;
pub fn PXIDEV_SPIWriteRead(bytesRead: *mut u32_,
initialWaitOperation: u64_,
writeBuffer: *mut PXIDEV_SPIBuffer,
readBuffer: *mut PXIDEV_SPIBuffer) -> Result;
}
use ::types::*;

42
ctru-sys/src/services/qtm.rs
Unescape View File

@ -1,42 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct QTM_HeadTrackingInfoCoord {
pub x: f32,
pub y: f32,
}
impl ::core::default::Default for QTM_HeadTrackingInfoCoord {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct QTM_HeadTrackingInfo {
pub flags: [u8_; 5usize],
pub padding: [u8_; 3usize],
pub floatdata_x08: f32,
pub coords0: [QTM_HeadTrackingInfoCoord; 4usize],
pub unk_x2c: [u32_; 5usize],
}
impl ::core::default::Default for QTM_HeadTrackingInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn qtmInit() -> Result;
pub fn qtmExit();
pub fn qtmCheckInitialized() -> u8;
pub fn qtmCheckHeadFullyDetected(info: *mut QTM_HeadTrackingInfo) -> u8;
pub fn qtmConvertCoordToScreen(coord: *mut QTM_HeadTrackingInfoCoord,
screen_width: *mut f32,
screen_height: *mut f32, x: *mut u32_,
y: *mut u32_) -> Result;
pub fn QTM_GetHeadTrackingInfo(val: u64_, out: *mut QTM_HeadTrackingInfo)
-> Result;
}
use ::types::*;

108
ctru-sys/src/services/soc.rs
Unescape View File

@ -1,108 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum NetworkOpt {
NETOPT_MAC_ADDRESS = 4100,
NETOPT_ARP_TABLE = 12290,
NETOPT_IP_INFO = 16387,
NETOPT_IP_MTU = 16388,
NETOPT_ROUTING_TABLE = 16390,
NETOPT_UDP_NUMBER = 32770,
NETOPT_UDP_TABLE = 32771,
NETOPT_TCP_NUMBER = 36866,
NETOPT_TCP_TABLE = 36867,
NETOPT_DNS_TABLE = 45059,
NETOPT_DHCP_LEASE_TIME = 49153,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SOCU_ARPTableEntry {
pub unk0: u32_,
pub ip: in_addr,
pub mac: [u8_; 6usize],
pub padding: [u8_; 2usize],
}
impl ::core::default::Default for SOCU_ARPTableEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SOCU_IPInfo {
pub ip: in_addr,
pub netmask: in_addr,
pub broadcast: in_addr,
}
impl ::core::default::Default for SOCU_IPInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SOCU_RoutingTableEntry {
pub dest_ip: in_addr,
pub netmask: in_addr,
pub gateway: in_addr,
pub flags: u32_,
pub time: u64_,
}
impl ::core::default::Default for SOCU_RoutingTableEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SOCU_UDPTableEntry {
pub local: sockaddr_storage,
pub remote: sockaddr_storage,
}
impl ::core::default::Default for SOCU_UDPTableEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SOCU_TCPTableEntry {
pub state: u32_,
pub local: sockaddr_storage,
pub remote: sockaddr_storage,
}
impl ::core::default::Default for SOCU_TCPTableEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SOCU_DNSTableEntry {
pub family: u32_,
pub ip: in_addr,
pub padding: [u8_; 12usize],
}
impl ::core::default::Default for SOCU_DNSTableEntry {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn socInit(context_addr: *mut u32_, context_size: u32_) -> Result;
pub fn socExit() -> Result;
pub fn gethostid() -> ::libc::c_long;
pub fn gethostname(name: *mut ::libc::c_char, namelen: ::libc::size_t)
-> ::libc::c_int;
pub fn SOCU_ShutdownSockets() -> ::libc::c_int;
pub fn SOCU_CloseSockets() -> ::libc::c_int;
pub fn SOCU_GetNetworkOpt(level: ::libc::c_int, optname: NetworkOpt,
optval: *mut ::libc::c_void,
optlen: *mut socklen_t) -> ::libc::c_int;
pub fn SOCU_GetIPInfo(ip: *mut in_addr, netmask: *mut in_addr,
broadcast: *mut in_addr) -> ::libc::c_int;
pub fn SOCU_AddGlobalSocket(sockfd: ::libc::c_int) -> ::libc::c_int;
}
use ::types::*;
use sys::socket::*;
use sys::inaddr::*;

18
ctru-sys/src/services/srvpm.rs
Unescape View File

@ -1,18 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
extern "C" {
pub fn srvPmInit() -> Result;
pub fn srvPmExit();
pub fn SRVPM_PublishToProcess(notificationId: u32_, process: Handle)
-> Result;
pub fn SRVPM_PublishToAll(notificationId: u32_) -> Result;
pub fn SRVPM_RegisterProcess(procid: u32_, count: u32_,
serviceaccesscontrol: *mut ::libc::c_void)
-> Result;
pub fn SRVPM_UnregisterProcess(procid: u32_) -> Result;
}
use ::types::*;

115
ctru-sys/src/services/sslc.rs
Unescape View File

@ -1,115 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct sslcContext {
pub servhandle: Handle,
pub sslchandle: u32_,
pub sharedmem_handle: Handle,
}
impl ::core::default::Default for sslcContext {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SSLC_DefaultRootCert {
SSLC_DefaultRootCert_Nintendo_CA = 1,
SSLC_DefaultRootCert_Nintendo_CA_G2 = 2,
SSLC_DefaultRootCert_Nintendo_CA_G3 = 3,
SSLC_DefaultRootCert_Nintendo_Class2_CA = 4,
SSLC_DefaultRootCert_Nintendo_Class2_CA_G2 = 5,
SSLC_DefaultRootCert_Nintendo_Class2_CA_G3 = 6,
SSLC_DefaultRootCert_CyberTrust = 7,
SSLC_DefaultRootCert_AddTrust_External_CA = 8,
SSLC_DefaultRootCert_COMODO = 9,
SSLC_DefaultRootCert_USERTrust = 10,
SSLC_DefaultRootCert_DigiCert_EV = 11,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum SSLC_DefaultClientCert { SSLC_DefaultClientCert_ClCertA = 64, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum Enum_Unnamed1 {
SSLCOPT_Default = 0,
SSLCOPT_DisableVerify = 512,
SSLCOPT_TLSv10 = 2048,
}
extern "C" {
pub fn sslcInit(session_handle: Handle) -> Result;
pub fn sslcExit();
pub fn sslcCreateRootCertChain(RootCertChain_contexthandle: *mut u32_)
-> Result;
pub fn sslcDestroyRootCertChain(RootCertChain_contexthandle: u32_)
-> Result;
pub fn sslcAddTrustedRootCA(RootCertChain_contexthandle: u32_,
cert: *const u8_, certsize: u32_,
cert_contexthandle: *mut u32_) -> Result;
pub fn sslcRootCertChainAddDefaultCert(RootCertChain_contexthandle: u32_,
certID: SSLC_DefaultRootCert,
cert_contexthandle: *mut u32_)
-> Result;
pub fn sslcRootCertChainRemoveCert(RootCertChain_contexthandle: u32_,
cert_contexthandle: u32_) -> Result;
pub fn sslcCreate8CertChain(CertChain_contexthandle: *mut u32_) -> Result;
pub fn sslcDestroy8CertChain(CertChain_contexthandle: u32_) -> Result;
pub fn sslc8CertChainAddCert(CertChain_contexthandle: u32_,
cert: *const u8_, certsize: u32_,
cert_contexthandle: *mut u32_) -> Result;
pub fn sslc8CertChainAddDefaultCert(CertChain_contexthandle: u32_,
certID: u8_,
cert_contexthandle: *mut u32_)
-> Result;
pub fn sslc8CertChainRemoveCert(CertChain_contexthandle: u32_,
cert_contexthandle: u32_) -> Result;
pub fn sslcOpenClientCertContext(cert: *const u8_, certsize: u32_,
key: *const u8_, keysize: u32_,
ClientCert_contexthandle: *mut u32_)
-> Result;
pub fn sslcOpenDefaultClientCertContext(certID: SSLC_DefaultClientCert,
ClientCert_contexthandle:
*mut u32_) -> Result;
pub fn sslcCloseClientCertContext(ClientCert_contexthandle: u32_)
-> Result;
pub fn sslcSeedRNG() -> Result;
pub fn sslcGenerateRandomData(buf: *mut u8_, size: u32_) -> Result;
pub fn sslcCreateContext(context: *mut sslcContext, sockfd: ::libc::c_int,
input_opt: u32_, hostname: *const ::libc::c_char)
-> Result;
pub fn sslcDestroyContext(context: *mut sslcContext) -> Result;
pub fn sslcStartConnection(context: *mut sslcContext,
internal_retval: *mut ::libc::c_int,
out: *mut u32_) -> Result;
pub fn sslcRead(context: *mut sslcContext, buf: *mut ::libc::c_void,
len: ::libc::size_t, peek: u8) -> Result;
pub fn sslcWrite(context: *mut sslcContext, buf: *const ::libc::c_void,
len: ::libc::size_t) -> Result;
pub fn sslcContextSetRootCertChain(context: *mut sslcContext,
handle: u32_) -> Result;
pub fn sslcContextSetClientCert(context: *mut sslcContext, handle: u32_)
-> Result;
pub fn sslcContextSetHandle8(context: *mut sslcContext, handle: u32_)
-> Result;
pub fn sslcContextClearOpt(context: *mut sslcContext, bitmask: u32_)
-> Result;
pub fn sslcContextGetProtocolCipher(context: *mut sslcContext,
outprotocols: *mut ::libc::c_char,
outprotocols_maxsize: u32_,
outcipher: *mut ::libc::c_char,
outcipher_maxsize: u32_) -> Result;
pub fn sslcContextGetState(context: *mut sslcContext, out: *mut u32_)
-> Result;
pub fn sslcContextInitSharedmem(context: *mut sslcContext, buf: *mut u8_,
size: u32_) -> Result;
pub fn sslcAddCert(context: *mut sslcContext, buf: *const u8_, size: u32_)
-> Result;
}
use ::types::*;

6
ctru-sys/src/services/uds.rs
Unescape View File

@ -1,6 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]

184
ctru-sys/src/services/y2r.rs
Unescape View File

@ -1,184 +0,0 @@
use ::types::*;
use ::libc::c_void;
#[derive(Clone, Copy)]
#[repr(C)]
pub enum Y2RU_InputFormat {
INPUT_YUV422_INDIV_8 = 0,
INPUT_YUV420_INDIV_8 = 1,
INPUT_YUV422_INDIV_16 = 2,
INPUT_YUV420_INDIV_16 = 3,
INPUT_YUV422_BATCH = 4,
}
#[derive(Clone, Copy)]
#[repr(C)]
pub enum Y2RU_OutputFormat {
OUTPUT_RGB_32 = 0,
OUTPUT_RGB_24 = 1,
OUTPUT_RGB_16_555 = 2,
OUTPUT_RGB_16_565 = 3,
}
#[derive(Clone, Copy)]
#[repr(C)]
pub enum Y2RU_Rotation {
ROTATION_NONE = 0,
ROTATION_CLOCKWISE_90 = 1,
ROTATION_CLOCKWISE_180 = 2,
ROTATION_CLOCKWISE_270 = 3,
}
#[derive(Clone, Copy)]
#[repr(C)]
pub enum Y2RU_BlockAlignment {
BLOCK_LINE = 0,
BLOCK_8_BY_8 = 1,
}
#[repr(C)]
#[derive(Copy)]
pub struct Y2RU_ColorCoefficients {
pub rgb_Y: u16,
pub r_V: u16,
pub g_V: u16,
pub g_U: u16,
pub b_U: u16,
pub r_offset: u16,
pub g_offset: u16,
pub b_offset: u16,
}
impl ::core::clone::Clone for Y2RU_ColorCoefficients {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Y2RU_ColorCoefficients {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Clone, Copy)]
#[repr(C)]
pub enum Y2RU_StandardCoefficient {
COEFFICIENT_ITU_R_BT_601 = 0,
COEFFICIENT_ITU_R_BT_709 = 1,
COEFFICIENT_ITU_R_BT_601_SCALING = 2,
COEFFICIENT_ITU_R_BT_709_SCALING = 3,
}
#[repr(C)]
#[derive(Copy)]
pub struct Y2RU_ConversionParams {
pub _bindgen_bitfield_1_: Y2RU_InputFormat,
pub _bindgen_bitfield_2_: Y2RU_OutputFormat,
pub _bindgen_bitfield_3_: Y2RU_Rotation,
pub _bindgen_bitfield_4_: Y2RU_BlockAlignment,
pub input_line_width: s16,
pub input_lines: s16,
pub _bindgen_bitfield_5_: Y2RU_StandardCoefficient,
pub unused: u8,
pub alpha: u16,
}
impl ::core::clone::Clone for Y2RU_ConversionParams {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Y2RU_ConversionParams {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Y2RU_DitheringWeightParams {
pub w0_xEven_yEven: u16,
pub w0_xOdd_yEven: u16,
pub w0_xEven_yOdd: u16,
pub w0_xOdd_yOdd: u16,
pub w1_xEven_yEven: u16,
pub w1_xOdd_yEven: u16,
pub w1_xEven_yOdd: u16,
pub w1_xOdd_yOdd: u16,
pub w2_xEven_yEven: u16,
pub w2_xOdd_yEven: u16,
pub w2_xEven_yOdd: u16,
pub w2_xOdd_yOdd: u16,
pub w3_xEven_yEven: u16,
pub w3_xOdd_yEven: u16,
pub w3_xEven_yOdd: u16,
pub w3_xOdd_yOdd: u16,
}
impl ::core::clone::Clone for Y2RU_DitheringWeightParams {
fn clone(&self) -> Self { *self }
}
impl ::core::default::Default for Y2RU_DitheringWeightParams {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn y2rInit() -> Result;
pub fn y2rExit();
pub fn Y2RU_SetInputFormat(format: Y2RU_InputFormat) -> Result;
pub fn Y2RU_GetInputFormat(format: *mut Y2RU_InputFormat) -> Result;
pub fn Y2RU_SetOutputFormat(format: Y2RU_OutputFormat) -> Result;
pub fn Y2RU_GetOutputFormat(format: *mut Y2RU_OutputFormat) -> Result;
pub fn Y2RU_SetRotation(rotation: Y2RU_Rotation) -> Result;
pub fn Y2RU_GetRotation(rotation: *mut Y2RU_Rotation) -> Result;
pub fn Y2RU_SetBlockAlignment(alignment: Y2RU_BlockAlignment) -> Result;
pub fn Y2RU_GetBlockAlignment(alignment: *mut Y2RU_BlockAlignment)
-> Result;
pub fn Y2RU_SetSpacialDithering(enable: u8) -> Result;
pub fn Y2RU_GetSpacialDithering(enabled: *mut u8) -> Result;
pub fn Y2RU_SetTemporalDithering(enable: u8) -> Result;
pub fn Y2RU_GetTemporalDithering(enabled: *mut u8) -> Result;
pub fn Y2RU_SetInputLineWidth(line_width: u16) -> Result;
pub fn Y2RU_GetInputLineWidth(line_width: *mut u16) -> Result;
pub fn Y2RU_SetInputLines(num_lines: u16) -> Result;
pub fn Y2RU_GetInputLines(num_lines: *mut u16) -> Result;
pub fn Y2RU_SetCoefficients(coefficients: *const Y2RU_ColorCoefficients)
-> Result;
pub fn Y2RU_GetCoefficients(coefficients: *mut Y2RU_ColorCoefficients)
-> Result;
pub fn Y2RU_SetStandardCoefficient(coefficient: Y2RU_StandardCoefficient)
-> Result;
pub fn Y2RU_GetStandardCoefficient(coefficients:
*mut Y2RU_ColorCoefficients,
standardCoeff:
Y2RU_StandardCoefficient)
-> Result;
pub fn Y2RU_SetAlpha(alpha: u16) -> Result;
pub fn Y2RU_GetAlpha(alpha: *mut u16) -> Result;
pub fn Y2RU_SetTransferEndInterrupt(should_interrupt: u8) -> Result;
pub fn Y2RU_GetTransferEndInterrupt(should_interrupt: *mut u8) -> Result;
pub fn Y2RU_GetTransferEndEvent(end_event: *mut Handle) -> Result;
pub fn Y2RU_SetSendingY(src_buf: *const c_void,
image_size: u32, transfer_unit: s16,
transfer_gap: s16) -> Result;
pub fn Y2RU_SetSendingU(src_buf: *const c_void,
image_size: u32, transfer_unit: s16,
transfer_gap: s16) -> Result;
pub fn Y2RU_SetSendingV(src_buf: *const c_void,
image_size: u32, transfer_unit: s16,
transfer_gap: s16) -> Result;
pub fn Y2RU_SetSendingYUYV(src_buf: *const c_void,
image_size: u32, transfer_unit: s16,
transfer_gap: s16) -> Result;
pub fn Y2RU_SetReceiving(dst_buf: *mut c_void,
image_size: u32, transfer_unit: s16,
transfer_gap: s16) -> Result;
pub fn Y2RU_IsDoneSendingY(is_done: *mut u8) -> Result;
pub fn Y2RU_IsDoneSendingU(is_done: *mut u8) -> Result;
pub fn Y2RU_IsDoneSendingV(is_done: *mut u8) -> Result;
pub fn Y2RU_IsDoneSendingYUYV(is_done: *mut u8) -> Result;
pub fn Y2RU_IsDoneReceiving(is_done: *mut u8) -> Result;
pub fn Y2RU_SetDitheringWeightParams(params:
*const Y2RU_DitheringWeightParams)
-> Result;
pub fn Y2RU_GetDitheringWeightParams(params:
*mut Y2RU_DitheringWeightParams)
-> Result;
pub fn Y2RU_SetConversionParams(params: *const Y2RU_ConversionParams)
-> Result;
pub fn Y2RU_StartConversion() -> Result;
pub fn Y2RU_StopConversion() -> Result;
pub fn Y2RU_IsBusyConversion(is_busy: *mut u8) -> Result;
pub fn Y2RU_PingProcess(ping: *mut u8) -> Result;
pub fn Y2RU_DriverInitialize() -> Result;
pub fn Y2RU_DriverFinalize() -> Result;
}

15
ctru-sys/src/srv.rs
Unescape View File

@ -1,15 +0,0 @@
use {Result, Handle};
use libc::c_void;
extern "C" {
pub fn srvInit() -> Result;
pub fn srvExit() -> Result;
pub fn srvGetSessionHandle() -> * const Handle;
pub fn srvRegisterClient() -> Result;
pub fn srvGetServiceHandle(out: *mut Handle, name: * const u8) -> Result;
pub fn srvRegisterService(out: *mut Handle, name: * const u8) -> Result;
pub fn srvUnregisterService(name: * const u8) -> Result;
pub fn srvPmInit() -> Result;
pub fn srvRegisterProcess(procid: u32, count: u32, serviceaccesscontrol: *mut c_void) -> Result;
pub fn srvUnregisterProcess(procid: u32) -> Result;
}

479
ctru-sys/src/svc.rs
Unescape View File

@ -1,479 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum MemOp {
MEMOP_FREE = 1,
MEMOP_RESERVE = 2,
MEMOP_ALLOC = 3,
MEMOP_MAP = 4,
MEMOP_UNMAP = 5,
MEMOP_PROT = 6,
MEMOP_REGION_APP = 256,
MEMOP_REGION_SYSTEM = 512,
MEMOP_REGION_BASE = 768,
MEMOP_OP_MASK = 255,
MEMOP_REGION_MASK = 3840,
MEMOP_LINEAR_FLAG = 65536,
MEMOP_ALLOC_LINEAR = 65539,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum MemState {
MEMSTATE_FREE = 0,
MEMSTATE_RESERVED = 1,
MEMSTATE_IO = 2,
MEMSTATE_STATIC = 3,
MEMSTATE_CODE = 4,
MEMSTATE_PRIVATE = 5,
MEMSTATE_SHARED = 6,
MEMSTATE_CONTINUOUS = 7,
MEMSTATE_ALIASED = 8,
MEMSTATE_ALIAS = 9,
MEMSTATE_ALIASCODE = 10,
MEMSTATE_LOCKED = 11,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum MemPerm {
MEMPERM_READ = 1,
MEMPERM_WRITE = 2,
MEMPERM_EXECUTE = 4,
MEMPERM_DONTCARE = 268435456,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct MemInfo {
pub base_addr: u32_,
pub size: u32_,
pub perm: u32_,
pub state: u32_,
}
impl ::core::default::Default for MemInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct PageInfo {
pub flags: u32_,
}
impl ::core::default::Default for PageInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ArbitrationType {
ARBITRATION_SIGNAL = 0,
ARBITRATION_WAIT_IF_LESS_THAN = 1,
ARBITRATION_DECREMENT_AND_WAIT_IF_LESS_THAN = 2,
ARBITRATION_WAIT_IF_LESS_THAN_TIMEOUT = 3,
ARBITRATION_DECREMENT_AND_WAIT_IF_LESS_THAN_TIMEOUT = 4,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ResetType { RESET_ONESHOT = 0, RESET_STICKY = 1, RESET_PULSE = 2, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ThreadInfoType { THREADINFO_TYPE_UNKNOWN = 0, }
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ProcessEventReason { REASON_CREATE = 1, REASON_ATTACH = 2, }
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ProcessEvent {
pub program_id: u64_,
pub process_name: [u8_; 8usize],
pub process_id: u32_,
pub reason: u32_,
}
impl ::core::default::Default for ProcessEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ExitProcessEventReason {
EXITPROCESS_EVENT_NONE = 0,
EXITPROCESS_EVENT_TERMINATE = 1,
EXITPROCESS_EVENT_UNHANDLED_EXCEPTION = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ExitProcessEvent {
pub reason: u32_,
}
impl ::core::default::Default for ExitProcessEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CreateThreadEvent {
pub creator_thread_id: u32_,
pub base_addr: u32_,
pub entry_point: u32_,
}
impl ::core::default::Default for CreateThreadEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ExitThreadEventReason {
EXITTHREAD_EVENT_NONE = 0,
EXITTHREAD_EVENT_TERMINATE = 1,
EXITTHREAD_EVENT_UNHANDLED_EXC = 2,
EXITTHREAD_EVENT_TERMINATE_PROCESS = 3,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ExitThreadEvent {
pub reason: u32_,
}
impl ::core::default::Default for ExitThreadEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum UserBreakType {
USERBREAK_PANIC = 0,
USERBREAK_ASSERT = 1,
USERBREAK_USER = 2,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum ExceptionEventType {
EXC_EVENT_UNDEFINED_INSTRUCTION = 0,
EXC_EVENT_UNKNOWN1 = 1,
EXC_EVENT_UNKNOWN2 = 2,
EXC_EVENT_UNKNOWN3 = 3,
EXC_EVENT_ATTACH_BREAK = 4,
EXC_EVENT_BREAKPOINT = 5,
EXC_EVENT_USER_BREAK = 6,
EXC_EVENT_DEBUGGER_BREAK = 7,
EXC_EVENT_UNDEFINED_SYSCALL = 8,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ExceptionEvent {
pub type_: u32_,
pub address: u32_,
pub argument: u32_,
}
impl ::core::default::Default for ExceptionEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SchedulerInOutEvent {
pub clock_tick: u64_,
}
impl ::core::default::Default for SchedulerInOutEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct SyscallInOutEvent {
pub clock_tick: u64_,
pub syscall: u32_,
_bindgen_padding_0_: [u8; 4usize],
}
impl ::core::default::Default for SyscallInOutEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct OutputStringEvent {
pub string_addr: u32_,
pub string_size: u32_,
}
impl ::core::default::Default for OutputStringEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct MapEvent {
pub mapped_addr: u32_,
pub mapped_size: u32_,
pub memperm: u32_,
pub memstate: u32_,
}
impl ::core::default::Default for MapEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum DebugEventType {
DBG_EVENT_PROCESS = 0,
DBG_EVENT_CREATE_THREAD = 1,
DBG_EVENT_EXIT_THREAD = 2,
DBG_EVENT_EXIT_PROCESS = 3,
DBG_EVENT_EXCEPTION = 4,
DBG_EVENT_DLL_LOAD = 5,
DBG_EVENT_DLL_UNLOAD = 6,
DBG_EVENT_SCHEDULE_IN = 7,
DBG_EVENT_SCHEDULE_OUT = 8,
DBG_EVENT_SYSCALL_IN = 9,
DBG_EVENT_SYSCALL_OUT = 10,
DBG_EVENT_OUTPUT_STRING = 11,
DBG_EVENT_MAP = 12,
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct DebugEventInfo {
pub type_: u32_,
pub thread_id: u32_,
pub unknown: [u32_; 2usize],
pub _bindgen_data_1_: [u64; 3usize],
}
impl DebugEventInfo {
pub unsafe fn process(&mut self) -> *mut ProcessEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn create_thread(&mut self) -> *mut CreateThreadEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn exit_thread(&mut self) -> *mut ExitThreadEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn exit_process(&mut self) -> *mut ExitProcessEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn exception(&mut self) -> *mut ExceptionEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn scheduler(&mut self) -> *mut SchedulerInOutEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn syscall(&mut self) -> *mut SyscallInOutEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn output_string(&mut self) -> *mut OutputStringEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
pub unsafe fn map(&mut self) -> *mut MapEvent {
let raw: *mut u8 = ::core::mem::transmute(&self._bindgen_data_1_);
::core::mem::transmute(raw.offset(0))
}
}
impl ::core::default::Default for DebugEventInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CodeSetInfo {
pub name: [u8_; 8usize],
pub unk1: u16_,
pub unk2: u16_,
pub unk3: u32_,
pub text_addr: u32_,
pub text_size: u32_,
pub ro_addr: u32_,
pub ro_size: u32_,
pub rw_addr: u32_,
pub rw_size: u32_,
pub text_size_total: u32_,
pub ro_size_total: u32_,
pub rw_size_total: u32_,
pub unk4: u32_,
pub program_id: u64_,
}
impl ::core::default::Default for CodeSetInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct StartupInfo {
pub priority: ::libc::c_int,
pub stack_size: u32_,
pub argc: ::libc::c_int,
pub argv: *mut u16_,
pub envp: *mut u16_,
}
impl ::core::default::Default for StartupInfo {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn svcControlMemory(addr_out: *mut u32_, addr0: u32_, addr1: u32_,
size: u32_, op: MemOp, perm: MemPerm) -> Result;
pub fn svcControlProcessMemory(process: Handle, addr0: u32_, addr1: u32_,
size: u32_, type_: u32_, perm: u32_)
-> Result;
pub fn svcCreateMemoryBlock(memblock: *mut Handle, addr: u32_, size: u32_,
my_perm: MemPerm, other_perm: MemPerm)
-> Result;
pub fn svcMapMemoryBlock(memblock: Handle, addr: u32_, my_perm: MemPerm,
other_perm: MemPerm) -> Result;
pub fn svcMapProcessMemory(process: Handle, startAddr: u32_,
endAddr: u32_) -> Result;
pub fn svcUnmapProcessMemory(process: Handle, startAddr: u32_,
endAddr: u32_) -> Result;
pub fn svcUnmapMemoryBlock(memblock: Handle, addr: u32_) -> Result;
pub fn svcStartInterProcessDma(dma: *mut Handle, dstProcess: Handle,
dst: *mut ::libc::c_void,
srcProcess: Handle,
src: *const ::libc::c_void, size: u32_,
dmaConfig: *mut ::libc::c_void) -> Result;
pub fn svcStopDma(dma: Handle) -> Result;
pub fn svcGetDmaState(dmaState: *mut ::libc::c_void, dma: Handle)
-> Result;
pub fn svcQueryMemory(info: *mut MemInfo, out: *mut PageInfo, addr: u32_)
-> Result;
pub fn svcQueryProcessMemory(info: *mut MemInfo, out: *mut PageInfo,
process: Handle, addr: u32_) -> Result;
pub fn svcInvalidateProcessDataCache(process: Handle,
addr: *mut ::libc::c_void,
size: u32_) -> Result;
pub fn svcFlushProcessDataCache(process: Handle,
addr: *const ::libc::c_void, size: u32_)
-> Result;
pub fn svcReadProcessMemory(buffer: *mut ::libc::c_void, debug: Handle,
addr: u32_, size: u32_) -> Result;
pub fn svcWriteProcessMemory(debug: Handle, buffer: *const ::libc::c_void,
addr: u32_, size: u32_) -> Result;
pub fn svcOpenProcess(process: *mut Handle, processId: u32_) -> Result;
pub fn svcExitProcess();
pub fn svcTerminateProcess(process: Handle) -> Result;
pub fn svcGetProcessInfo(out: *mut s64, process: Handle, type_: u32_)
-> Result;
pub fn svcGetProcessId(out: *mut u32_, handle: Handle) -> Result;
pub fn svcGetProcessList(processCount: *mut s32, processIds: *mut u32_,
processIdMaxCount: s32) -> Result;
pub fn svcCreatePort(portServer: *mut Handle, portClient: *mut Handle,
name: *const ::libc::c_char, maxSessions: s32)
-> Result;
pub fn svcConnectToPort(out: *mut Handle, portName: *const ::libc::c_char)
-> Result;
pub fn svcCreateCodeSet(out: *mut Handle, info: *const CodeSetInfo,
code_ptr: *mut ::libc::c_void,
ro_ptr: *mut ::libc::c_void,
data_ptr: *mut ::libc::c_void) -> Result;
pub fn svcCreateProcess(out: *mut Handle, codeset: Handle,
arm11kernelcaps: *const u32_,
arm11kernelcaps_num: u32_) -> Result;
pub fn svcSetProcessAffinityMask(process: Handle,
affinitymask: *const u8_,
processorcount: s32) -> Result;
pub fn svcSetProcessIdealProcessor(process: Handle, processorid: s32)
-> Result;
pub fn svcRun(process: Handle, info: *const StartupInfo) -> Result;
pub fn svcCreateThread(thread: *mut Handle, entrypoint: ThreadFunc,
arg: u32_, stack_top: *mut u32_,
thread_priority: s32, processor_id: s32) -> Result;
pub fn svcOpenThread(thread: *mut Handle, process: Handle, threadId: u32_)
-> Result;
pub fn svcExitThread();
pub fn svcSleepThread(ns: s64);
pub fn svcGetThreadPriority(out: *mut s32, handle: Handle) -> Result;
pub fn svcSetThreadPriority(thread: Handle, prio: s32) -> Result;
pub fn svcGetThreadAffinityMask(affinitymask: *mut u8_, thread: Handle,
processorcount: s32) -> Result;
pub fn svcSetThreadAffinityMask(thread: Handle, affinitymask: *const u8_,
processorcount: s32) -> Result;
pub fn svcGetThreadIdealProcessor(processorid: *mut s32, thread: Handle)
-> Result;
pub fn svcSetThreadIdealProcessor(thread: Handle, processorid: s32)
-> Result;
pub fn svcGetProcessorID() -> s32;
pub fn svcGetThreadId(out: *mut u32_, handle: Handle) -> Result;
pub fn svcGetResourceLimit(resourceLimit: *mut Handle, process: Handle)
-> Result;
pub fn svcGetResourceLimitLimitValues(values: *mut s64,
resourceLimit: Handle,
names: *mut u32_, nameCount: s32)
-> Result;
pub fn svcGetResourceLimitCurrentValues(values: *mut s64,
resourceLimit: Handle,
names: *mut u32_, nameCount: s32)
-> Result;
pub fn svcGetProcessIdOfThread(out: *mut u32_, handle: Handle) -> Result;
pub fn svcGetThreadInfo(out: *mut s64, thread: Handle,
type_: ThreadInfoType) -> Result;
pub fn svcCreateMutex(mutex: *mut Handle, initially_locked: u8) -> Result;
pub fn svcReleaseMutex(handle: Handle) -> Result;
pub fn svcCreateSemaphore(semaphore: *mut Handle, initial_count: s32,
max_count: s32) -> Result;
pub fn svcReleaseSemaphore(count: *mut s32, semaphore: Handle,
release_count: s32) -> Result;
pub fn svcCreateEvent(event: *mut Handle, reset_type: ResetType)
-> Result;
pub fn svcSignalEvent(handle: Handle) -> Result;
pub fn svcClearEvent(handle: Handle) -> Result;
pub fn svcWaitSynchronization(handle: Handle, nanoseconds: s64) -> Result;
pub fn svcWaitSynchronizationN(out: *mut s32, handles: *mut Handle,
handles_num: s32, wait_all: u8,
nanoseconds: s64) -> Result;
pub fn svcCreateAddressArbiter(arbiter: *mut Handle) -> Result;
pub fn svcArbitrateAddress(arbiter: Handle, addr: u32_,
type_: ArbitrationType, value: s32,
nanoseconds: s64) -> Result;
pub fn svcSendSyncRequest(session: Handle) -> Result;
pub fn svcAcceptSession(session: *mut Handle, port: Handle) -> Result;
pub fn svcReplyAndReceive(index: *mut s32, handles: *mut Handle,
handleCount: s32, replyTarget: Handle)
-> Result;
pub fn svcBindInterrupt(interruptId: u32_, event: Handle, priority: s32,
isManualClear: u8) -> Result;
pub fn svcUnbindInterrupt(interruptId: u32_, event: Handle) -> Result;
pub fn svcCreateTimer(timer: *mut Handle, reset_type: ResetType)
-> Result;
pub fn svcSetTimer(timer: Handle, initial: s64, interval: s64) -> Result;
pub fn svcCancelTimer(timer: Handle) -> Result;
pub fn svcClearTimer(timer: Handle) -> Result;
pub fn svcGetSystemTick() -> u64_;
pub fn svcCloseHandle(handle: Handle) -> Result;
pub fn svcDuplicateHandle(out: *mut Handle, original: Handle) -> Result;
pub fn svcGetSystemInfo(out: *mut s64, type_: u32_, param: s32) -> Result;
pub fn svcKernelSetState(type_: u32_, param0: u32_, param1: u32_,
param2: u32_) -> Result;
pub fn svcBreak(breakReason: UserBreakType);
pub fn svcOutputDebugString(str: *const ::libc::c_char,
length: ::libc::c_int) -> Result;
pub fn svcDebugActiveProcess(debug: *mut Handle, processId: u32_)
-> Result;
pub fn svcBreakDebugProcess(debug: Handle) -> Result;
pub fn svcTerminateDebugProcess(debug: Handle) -> Result;
pub fn svcGetProcessDebugEvent(info: *mut DebugEventInfo, debug: Handle)
-> Result;
pub fn svcContinueDebugEvent(debug: Handle, flags: u32_) -> Result;
pub fn svcBackdoor(callback:
::core::option::Option<extern "C" fn() -> s32>)
-> Result;
}
use ::types::*;

40
ctru-sys/src/synchronization.rs
Unescape View File

@ -1,40 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
use Handle;
use svc::ResetType;
use super::lock::*;
pub type LightLock = _LOCK_T;
pub type RecursiveLock = _LOCK_RECURSIVE_T;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct LightEvent {
pub state: i32,
pub lock: LightLock,
}
impl ::core::default::Default for LightEvent {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn __sync_get_arbiter() -> Handle;
pub fn LightLock_Init(lock: *mut LightLock);
pub fn LightLock_Lock(lock: *const LightLock);
pub fn LightLock_TryLock(lock: *const LightLock) -> ::libc::c_int;
pub fn LightLock_Unlock(lock: *const LightLock);
pub fn RecursiveLock_Init(lock: *mut RecursiveLock);
pub fn RecursiveLock_Lock(lock: *const RecursiveLock);
pub fn RecursiveLock_TryLock(lock: *const RecursiveLock) -> ::libc::c_int;
pub fn RecursiveLock_Unlock(lock: *const RecursiveLock);
pub fn LightEvent_Init(event: *mut LightEvent, reset_type: ResetType);
pub fn LightEvent_Clear(event: *mut LightEvent);
pub fn LightEvent_Pulse(event: *mut LightEvent);
pub fn LightEvent_Signal(event: *mut LightEvent);
pub fn LightEvent_TryWait(event: *mut LightEvent) -> ::libc::c_int;
pub fn LightEvent_Wait(event: *mut LightEvent);
}

42
ctru-sys/src/sys/inaddr.rs
Unescape View File

@ -1,42 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
use super::socket::*;
pub type in_port_t = ::libc::uint16_t;
pub type in_addr_t = ::libc::uint32_t;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct in_addr {
pub s_addr: in_addr_t,
}
impl ::core::default::Default for in_addr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct sockaddr_in {
pub sin_family: sa_family_t,
pub sin_port: in_port_t,
pub sin_addr: in_addr,
pub sin_zero: [::libc::c_uchar; 8usize],
}
impl ::core::default::Default for sockaddr_in {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct ip_mreq {
pub imr_multiaddr: in_addr,
pub imr_interface: in_addr,
}
impl ::core::default::Default for ip_mreq {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}

92
ctru-sys/src/sys/libc.rs
Unescape View File

@ -1,92 +0,0 @@
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
pub const STDOUT_FILENO: c_int = 1;
#[repr(u8)]
pub enum c_void {
__variant1,
__variant2,
}
pub type c_schar = i8;
pub type c_uchar = u8;
pub type c_char = u8;
pub type c_short = i16;
pub type c_ushort = u16;
pub type c_int = i32;
pub type c_uint = u32;
pub type c_long = i32;
pub type c_ulong = u32;
pub type c_longlong = i64;
pub type c_ulonglong = u64;
pub type c_float = f32;
pub type c_double = f64;
pub type size_t = usize;
pub type ssize_t = isize;
pub type u_char = c_uchar;
pub type u_short = c_ushort;
pub type u_int = c_uint;
pub type u_long = c_ulong;
pub type ushort = c_ushort;
pub type uint_ = c_uint;
pub type ulong = c_ulong;
pub type clock_t = c_ulong;
pub type time_t = c_long;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct timespec {
pub tv_sec: time_t,
pub tv_nsec: c_long,
}
impl ::core::default::Default for timespec {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct itimerspec {
pub it_interval: timespec,
pub it_value: timespec,
}
impl ::core::default::Default for itimerspec {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type daddr_t = c_long;
pub type caddr_t = *mut c_char;
pub type ino_t = c_uint;
pub type off_t = c_long;
pub type dev_t = c_int;
pub type uid_t = c_ushort;
pub type gid_t = c_ushort;
pub type pid_t = c_int;
pub type key_t = c_long;
pub type mode_t = c_uint;
pub type nlink_t = c_ushort;
pub type fd_mask = c_long;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct _types_fd_set {
pub fds_bits: [fd_mask; 1usize],
}
impl ::core::default::Default for _types_fd_set {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type clockid_t = c_ulong;
pub type timer_t = c_ulong;
pub type useconds_t = c_ulong;
pub type suseconds_t = c_long;
pub type fsblkcnt_t = c_uint;
pub type fsfilcnt_t = c_uint;
extern "C" {
pub fn memchr(cx: *const c_void, c: c_int, n: ::libc::size_t) -> *mut c_void;
pub fn memrchr(cx: *const c_void, c: c_int, n: ::libc::size_t) -> *mut c_void;
pub fn strlen(cs: *const c_char) -> size_t;
pub fn write(fd: c_int, buf: *const c_void, count: ::libc::size_t) -> ::libc::ssize_t;
}

32
ctru-sys/src/sys/lock.rs
Unescape View File

@ -1,32 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
pub type _LOCK_T = i32;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct __lock_t {
pub lock: _LOCK_T,
pub thread_tag: u32,
pub counter: u32,
}
impl ::core::default::Default for __lock_t {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
pub type _LOCK_RECURSIVE_T = __lock_t;
extern "C" {
pub fn __libc_lock_init(lock: *mut _LOCK_T);
pub fn __libc_lock_init_recursive(lock: *mut _LOCK_RECURSIVE_T);
pub fn __libc_lock_close(lock: *mut _LOCK_T);
pub fn __libc_lock_close_recursive(lock: *mut _LOCK_RECURSIVE_T);
pub fn __libc_lock_acquire(lock: *mut _LOCK_T);
pub fn __libc_lock_acquire_recursive(lock: *mut _LOCK_RECURSIVE_T);
pub fn __libc_lock_release(lock: *mut _LOCK_T);
pub fn __libc_lock_release_recursive(lock: *mut _LOCK_RECURSIVE_T);
pub fn __libc_lock_try_acquire(lock: *mut _LOCK_T) -> ::libc::c_int;
pub fn __libc_lock_try_acquire_recursive(lock: *mut _LOCK_RECURSIVE_T)
-> ::libc::c_int;
}

3
ctru-sys/src/sys/mod.rs
Unescape View File

@ -1,3 +0,0 @@
pub mod lock;
pub mod inaddr;
pub mod socket;

75
ctru-sys/src/sys/socket.rs
Unescape View File

@ -1,75 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
pub type socklen_t = ::libc::uint32_t;
pub type sa_family_t = ::libc::uint16_t;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct sockaddr {
pub sa_family: sa_family_t,
pub sa_data: [::libc::c_char; 0usize],
}
impl ::core::default::Default for sockaddr {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct sockaddr_storage {
pub ss_family: sa_family_t,
pub __ss_padding: [::libc::c_char; 26usize],
}
impl ::core::default::Default for sockaddr_storage {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct linger {
pub l_onoff: ::libc::c_int,
pub l_linger: ::libc::c_int,
}
impl ::core::default::Default for linger {
fn default() -> Self { unsafe { ::core::mem::zeroed() } }
}
extern "C" {
pub fn accept(sockfd: ::libc::c_int, addr: *mut sockaddr,
addrlen: *mut socklen_t) -> ::libc::c_int;
pub fn bind(sockfd: ::libc::c_int, addr: *const sockaddr,
addrlen: socklen_t) -> ::libc::c_int;
pub fn closesocket(sockfd: ::libc::c_int) -> ::libc::c_int;
pub fn connect(sockfd: ::libc::c_int, addr: *const sockaddr,
addrlen: socklen_t) -> ::libc::c_int;
pub fn getpeername(sockfd: ::libc::c_int, addr: *mut sockaddr,
addrlen: *mut socklen_t) -> ::libc::c_int;
pub fn getsockname(sockfd: ::libc::c_int, addr: *mut sockaddr,
addrlen: *mut socklen_t) -> ::libc::c_int;
pub fn getsockopt(sockfd: ::libc::c_int, level: ::libc::c_int,
optname: ::libc::c_int, optval: *mut ::libc::c_void,
optlen: *mut socklen_t) -> ::libc::c_int;
pub fn listen(sockfd: ::libc::c_int, backlog: ::libc::c_int)
-> ::libc::c_int;
pub fn recv(sockfd: ::libc::c_int, buf: *mut ::libc::c_void, len: ::libc::size_t,
flags: ::libc::c_int) -> ::libc::ssize_t;
pub fn recvfrom(sockfd: ::libc::c_int, buf: *mut ::libc::c_void,
len: ::libc::size_t, flags: ::libc::c_int,
src_addr: *mut sockaddr, addrlen: *mut socklen_t)
-> ::libc::ssize_t;
pub fn send(sockfd: ::libc::c_int, buf: *const ::libc::c_void,
len: ::libc::size_t, flags: ::libc::c_int) -> ::libc::ssize_t;
pub fn sendto(sockfd: ::libc::c_int, buf: *const ::libc::c_void,
len: ::libc::size_t, flags: ::libc::c_int,
dest_addr: *const sockaddr, addrlen: socklen_t) -> ::libc::ssize_t;
pub fn setsockopt(sockfd: ::libc::c_int, level: ::libc::c_int,
optname: ::libc::c_int, optval: *const ::libc::c_void,
optlen: socklen_t) -> ::libc::c_int;
pub fn shutdown(sockfd: ::libc::c_int, how: ::libc::c_int)
-> ::libc::c_int;
pub fn socket(domain: ::libc::c_int, type_: ::libc::c_int,
protocol: ::libc::c_int) -> ::libc::c_int;
pub fn sockatmark(sockfd: ::libc::c_int) -> ::libc::c_int;
}

19
ctru-sys/src/thread.rs
Unescape View File

@ -1,19 +0,0 @@
use {Handle, Result};
use libc::c_void;
use ThreadFunc;
pub enum Struct_Thread_tag { }
pub type Thread = *mut Struct_Thread_tag;
extern "C" {
pub fn threadCreate(entrypoint: ThreadFunc,
arg: *mut c_void, stack_size: usize,
prio: i32,
affinity: i32, detached: u8)
-> Thread;
pub fn threadGetHandle(thread: Thread) -> Handle;
pub fn threadGetExitCode(thread: Thread) -> i32;
pub fn threadFree(thread: Thread);
pub fn threadJoin(thread: Thread, timeout_ns: u64) -> Result;
pub fn threadGetCurrent() -> Thread;
pub fn threadExit(rc: i32);
}

27
ctru-sys/src/types.rs
Unescape View File

@ -1,27 +0,0 @@
/* automatically generated by rust-bindgen */
#![allow(dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case)]
pub type u8_ = u8;
pub type u16_ = u16;
pub type u32_ = u32;
pub type u64_ = u64;
pub type s8 = i8;
pub type s16 = i16;
pub type s32 = i32;
pub type s64 = i64;
pub type vu8 = u8_;
pub type vu16 = u16_;
pub type vu32 = u32_;
pub type vu64 = u64_;
pub type vs8 = s8;
pub type vs16 = s16;
pub type vs32 = s32;
pub type vs64 = s64;
pub type Handle = u32_;
pub type Result = s32;
pub type ThreadFunc =
::core::option::Option<unsafe extern "C" fn(arg1: *mut ::libc::c_void)>;
pub type voidfn = ::core::option::Option<extern "C" fn()>;

10
ctru-sys/src/vram.rs
Unescape View File

@ -1,10 +0,0 @@
use super::types::*;
extern "C" {
pub fn vramAlloc(size: isize) -> *mut c_void;
pub fn vramMemAlign(size: isize, alignment: isize) -> *mut c_void;
pub fn vramRealloc(mem: *mut isize, size: isize) -> *mut c_void;
pub fn vramFree(mem: *mut c_void) -> ();
pub fn vramSpaceFree() -> u32;
}
Write Preview
Loading…
Cancel
Save