diff --git a/common/include/libcdvd-rpc.h b/common/include/libcdvd-rpc.h
index 3736ff2020c..b20c084bdb8 100644
--- a/common/include/libcdvd-rpc.h
+++ b/common/include/libcdvd-rpc.h
@@ -131,11 +131,44 @@ typedef struct cdvdfsv_rpc4_outpacket_
     int m_padding[3];
 } cdvdfsv_rpc4_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_02_inpacket_
+{
+    sceCdCLOCK m_clock;
+} cdvdfsv_rpc3_02_inpacket_t;
+
 typedef struct cdvdfsv_rpc3_05_inpacket_
 {
     int m_param;
 } cdvdfsv_rpc3_05_inpacket_t;
 
+typedef struct cdvdfsv_rpc3_07_inpacket_
+{
+    u8 m_buffer[8];
+} cdvdfsv_rpc3_07_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_08_inpacket_
+{
+    u32 m_address;
+    u16 m_data;
+    u8 xpad1;
+    u8 xpad2;
+} cdvdfsv_rpc3_08_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_09_inpacket_
+{
+    u32 m_address;
+    u16 m_data;
+    u8 xpad1;
+    u8 xpad2;
+} cdvdfsv_rpc3_09_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_0A_inpacket_
+{
+    u8 m_enable_xor;
+    u8 m_enable_shift;
+    u8 m_shiftval;
+} cdvdfsv_rpc3_0A_inpacket_t;
+
 typedef struct cdvdfsv_rpc3_0B_inpacket_
 {
     u8 m_cmdNum;
@@ -144,11 +177,61 @@ typedef struct cdvdfsv_rpc3_0B_inpacket_
     u8 m_inBuff[16];
 } cdvdfsv_rpc3_0B_inpacket_t;
 
+typedef struct cdvdfsv_rpc3_0D_inpacket_
+{
+    u32 m_mode;
+} cdvdfsv_rpc3_0D_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_0E_inpacket_
+{
+    u8 m_mode;
+    u8 m_block;
+    // EE side sceCdOpenConfig max NumBlocks 0x44, each block 15 bytes -> 1020 bytes total
+    // Max size is 105 bytes (7 blocks) due to mechacon config limits
+    u8 m_NumBlocks;
+    u8 xpad1;
+} cdvdfsv_rpc3_0E_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_11_inpacket_
+{
+    u8 m_buffer[1020];
+} cdvdfsv_rpc3_11_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_13_inpacket_
+{
+    u8 m_buffer[8];
+} cdvdfsv_rpc3_13_inpacket_t;
+
 typedef struct cdvdfsv_rpc3_15_inpacket_
 {
     int m_mode;
 } cdvdfsv_rpc3_15_inpacket_t;
 
+typedef struct cdvdfsv_rpc3_19_inpacket_
+{
+    u32 m_mode;
+} cdvdfsv_rpc3_19_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_1B_inpacket_
+{
+    char m_buffer[16];
+} cdvdfsv_rpc3_1B_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_1D_inpacket_
+{
+    u32 m_spinctl;
+} cdvdfsv_rpc3_1D_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_1E_inpacket_
+{
+    u8 m_romname[4];
+} cdvdfsv_rpc3_1E_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_20_inpacket_
+{
+    u32 m_control;
+} cdvdfsv_rpc3_20_inpacket_t;
+
 typedef struct cdvdfsv_rpc3_22_inpacket_
 {
     int m_media;
@@ -166,14 +249,116 @@ typedef struct cdvdfsv_rpc3_25_inpacket_
     int m_timeout;
 } cdvdfsv_rpc3_25_inpacket_t;
 
+typedef struct cdvdfsv_rpc3_28_inpacket_
+{
+    sceCdCLOCK m_clock;
+    u16 m_userdata;
+    u32 m_flags;
+} cdvdfsv_rpc3_28_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_2B_inpacket_
+{
+    u32 m_param;
+} cdvdfsv_rpc3_2B_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_2D_inpacket_
+{
+    u32 m_arg1;
+} cdvdfsv_rpc3_2D_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_2E_inpacket_
+{
+    u32 m_arg1;
+    u32 m_arg2;
+} cdvdfsv_rpc3_2E_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_2F_inpacket_
+{
+    u32 m_arg1;
+} cdvdfsv_rpc3_2F_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_30_inpacket_
+{
+    u32 m_mode;
+} cdvdfsv_rpc3_30_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_31_inpacket_
+{
+    u32 m_param;
+} cdvdfsv_rpc3_31_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_35_inpacket_
+{
+    u32 m_param;
+} cdvdfsv_rpc3_35_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_3C_inpacket_
+{
+    u32 m_arg1;
+    u32 m_arg2;
+} cdvdfsv_rpc3_3C_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_3D_inpacket_
+{
+    u32 m_arg1;
+} cdvdfsv_rpc3_3D_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_3F_inpacket_
+{
+    u32 m_arg1;
+} cdvdfsv_rpc3_3F_inpacket_t;
+
+typedef struct cdvdfsv_rpc3_44_inpacket_
+{
+    u8 m_arg1;
+    u8 m_arg2[12];
+    u8 m_arg3[2];
+} cdvdfsv_rpc3_44_inpacket_t;
+
 typedef union cdvdfsv_rpc3_inpacket_
 {
+    // OSD add
+    cdvdfsv_rpc3_02_inpacket_t m_pkt_02;
+    // OSD add end
     cdvdfsv_rpc3_05_inpacket_t m_pkt_05;
+    // OSD add
+    cdvdfsv_rpc3_07_inpacket_t m_pkt_07;
+    cdvdfsv_rpc3_08_inpacket_t m_pkt_08;
+    cdvdfsv_rpc3_09_inpacket_t m_pkt_09;
+    cdvdfsv_rpc3_0A_inpacket_t m_pkt_0A;
+    // OSD add end
     cdvdfsv_rpc3_0B_inpacket_t m_pkt_0B;
+    // OSD add
+    cdvdfsv_rpc3_0D_inpacket_t m_pkt_0D;
+    cdvdfsv_rpc3_0E_inpacket_t m_pkt_0E;
+    cdvdfsv_rpc3_11_inpacket_t m_pkt_11;
+    cdvdfsv_rpc3_13_inpacket_t m_pkt_13;
+    // OSD add end
     cdvdfsv_rpc3_15_inpacket_t m_pkt_15;
+    // OSD add
+    cdvdfsv_rpc3_19_inpacket_t m_pkt_19;
+    cdvdfsv_rpc3_1B_inpacket_t m_pkt_1B;
+    cdvdfsv_rpc3_1D_inpacket_t m_pkt_1D;
+    cdvdfsv_rpc3_1E_inpacket_t m_pkt_1E;
+    cdvdfsv_rpc3_20_inpacket_t m_pkt_20;
+    // OSD add end
     cdvdfsv_rpc3_22_inpacket_t m_pkt_22;
     cdvdfsv_rpc3_23_inpacket_t m_pkt_23;
     cdvdfsv_rpc3_25_inpacket_t m_pkt_25;
+    // OSD add
+    cdvdfsv_rpc3_28_inpacket_t m_pkt_28;
+    cdvdfsv_rpc3_2B_inpacket_t m_pkt_2B;
+    cdvdfsv_rpc3_2D_inpacket_t m_pkt_2D;
+    cdvdfsv_rpc3_2E_inpacket_t m_pkt_2E;
+    cdvdfsv_rpc3_2F_inpacket_t m_pkt_2F;
+    cdvdfsv_rpc3_30_inpacket_t m_pkt_30;
+    cdvdfsv_rpc3_31_inpacket_t m_pkt_31;
+    cdvdfsv_rpc3_35_inpacket_t m_pkt_35;
+    cdvdfsv_rpc3_3C_inpacket_t m_pkt_3C;
+    cdvdfsv_rpc3_3D_inpacket_t m_pkt_3D;
+    cdvdfsv_rpc3_3F_inpacket_t m_pkt_3F;
+    cdvdfsv_rpc3_44_inpacket_t m_pkt_44;
+    // OSD add end
 } cdvdfsv_rpc3_inpacket_t;
 
 typedef struct cdvdfsv_rpc3_01_outpacket_
@@ -182,6 +367,12 @@ typedef struct cdvdfsv_rpc3_01_outpacket_
     sceCdCLOCK m_clock;
 } cdvdfsv_rpc3_01_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_02_outpacket_
+{
+    int m_retres;
+    sceCdCLOCK m_clock;
+} cdvdfsv_rpc3_02_outpacket_t;
+
 typedef struct cdvdfsv_rpc3_05_outpacket_
 {
     int m_retres;
@@ -195,17 +386,105 @@ typedef struct cdvdfsv_rpc3_06_outpacket_
     u8 m_buffer[8];
 } cdvdfsv_rpc3_06_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_07_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_07_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_08_outpacket_
+{
+    int m_retres;
+    u32 m_address;
+    u16 m_data;
+    u8 m_status;
+    u8 xpad1;
+} cdvdfsv_rpc3_08_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_09_outpacket_
+{
+    int m_retres;
+    u32 m_address;
+    u16 m_data;
+    u8 m_status;
+    u8 xpad1;
+} cdvdfsv_rpc3_09_outpacket_t;
+
 typedef struct cdvdfsv_rpc3_0B_outpacket_
 {
     u8 m_outbuf[16];
 } cdvdfsv_rpc3_0B_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_0E_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_0E_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_0F_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_0F_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_10_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u8 m_buffer[1020];
+} cdvdfsv_rpc3_10_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_11_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_11_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_12_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u8 m_buffer[8];
+} cdvdfsv_rpc3_12_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_13_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_13_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_14_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u8 m_buffer[4];
+} cdvdfsv_rpc3_14_outpacket_t;
+
 typedef struct cdvdfsv_rpc3_15_outpacket_
 {
     int m_retres;
     u32 m_status;
 } cdvdfsv_rpc3_15_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_17_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u8 m_buffer[10];
+} cdvdfsv_rpc3_17_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_18_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_18_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_19_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_19_outpacket_t;
+
 typedef struct cdvdfsv_rpc3_1A_outpacket_
 {
     int m_retres;
@@ -213,6 +492,30 @@ typedef struct cdvdfsv_rpc3_1A_outpacket_
     char m_buffer[16];
 } cdvdfsv_rpc3_1A_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_1B_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_1B_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_1C_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_1C_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_1F_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_1F_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_20_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_20_outpacket_t;
+
 typedef struct cdvdfsv_rpc3_21_outpacket_
 {
     int m_retres;
@@ -238,19 +541,210 @@ typedef struct cdvdfsv_rpc3_27_outpacket_
     unsigned int m_layer1_start;
 } cdvdfsv_rpc3_27_outpacket_t;
 
+typedef struct cdvdfsv_rpc3_28_outpacket_
+{
+    int m_retres;
+    sceCdCLOCK m_clock;
+} cdvdfsv_rpc3_28_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_29_outpacket_
+{
+    int m_retres;
+    sceCdCLOCK m_clock;
+    u16 m_userdata;
+    int m_flags;
+    u32 m_wakeupreason;
+} cdvdfsv_rpc3_29_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_2A_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u8 m_out[11];
+} cdvdfsv_rpc3_2A_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_2B_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_2B_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_2C_outpacket_
+{
+    int m_retres;
+    u32 m_arg2;
+    u32 m_arg1;
+} cdvdfsv_rpc3_2C_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_2E_outpacket_
+{
+    int m_retres;
+    u32 m_result2;
+    u32 m_result1;
+} cdvdfsv_rpc3_2E_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_2F_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_2F_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_30_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_30_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_31_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_31_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_32_outpacket_
+{
+    int m_retres;
+    u32 m_arg4;
+    u32 m_arg1;
+    unsigned int m_arg2;
+    unsigned int m_arg3;
+} cdvdfsv_rpc3_32_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_35_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_35_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_38_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u32 m_param;
+} cdvdfsv_rpc3_38_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_39_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_39_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_3A_outpacket_
+{
+    int m_retres;
+    u32 m_arg2;
+} cdvdfsv_rpc3_3A_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_3B_outpacket_
+{
+    int m_retres;
+    u32 m_arg2;
+    u32 m_arg1;
+} cdvdfsv_rpc3_3B_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_3C_outpacket_
+{
+    int m_retres;
+    u32 m_result2;
+    u32 m_result1;
+} cdvdfsv_rpc3_3C_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_3D_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_3D_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_3E_outpacket_
+{
+    int m_retres;
+    u32 m_result2;
+    u32 m_result1;
+} cdvdfsv_rpc3_3E_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_3F_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_3F_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_43_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+    u32 m_arg1[4];  // TODO u8[15]
+} cdvdfsv_rpc3_43_outpacket_t;
+
+typedef struct cdvdfsv_rpc3_44_outpacket_
+{
+    int m_retres;
+    u32 m_status;
+} cdvdfsv_rpc3_44_outpacket_t;
+
 typedef union cdvdfsv_rpc3_outpacket_
 {
     int m_retres;
     cdvdfsv_rpc3_01_outpacket_t m_pkt_01;
+    // OSD add
+    cdvdfsv_rpc3_02_outpacket_t m_pkt_02;
+    // OSD add end
     cdvdfsv_rpc3_05_outpacket_t m_pkt_05;
     cdvdfsv_rpc3_06_outpacket_t m_pkt_06;
+    // OSD add
+    cdvdfsv_rpc3_07_outpacket_t m_pkt_07;
+    cdvdfsv_rpc3_08_outpacket_t m_pkt_08;
+    cdvdfsv_rpc3_09_outpacket_t m_pkt_09;
+    // OSD add end
     cdvdfsv_rpc3_0B_outpacket_t m_pkt_0B;
+    // OSD add
+    cdvdfsv_rpc3_0E_outpacket_t m_pkt_0E;
+    cdvdfsv_rpc3_0F_outpacket_t m_pkt_0F;
+    cdvdfsv_rpc3_10_outpacket_t m_pkt_10;
+    cdvdfsv_rpc3_11_outpacket_t m_pkt_11;
+    cdvdfsv_rpc3_12_outpacket_t m_pkt_12;
+    cdvdfsv_rpc3_13_outpacket_t m_pkt_13;
+    cdvdfsv_rpc3_14_outpacket_t m_pkt_14;
+    // OSD add end
     cdvdfsv_rpc3_15_outpacket_t m_pkt_15;
+    // OSD add
+    cdvdfsv_rpc3_17_outpacket_t m_pkt_17;
+    cdvdfsv_rpc3_18_outpacket_t m_pkt_18;
+    cdvdfsv_rpc3_19_outpacket_t m_pkt_19;
+    // OSD add end
     cdvdfsv_rpc3_1A_outpacket_t m_pkt_1A;
+    // OSD add
+    cdvdfsv_rpc3_1B_outpacket_t m_pkt_1B;
+    cdvdfsv_rpc3_1C_outpacket_t m_pkt_1C;
+    cdvdfsv_rpc3_1F_outpacket_t m_pkt_1F;
+    cdvdfsv_rpc3_20_outpacket_t m_pkt_20;
+    // OSD add end
     cdvdfsv_rpc3_21_outpacket_t m_pkt_21;
     cdvdfsv_rpc3_24_outpacket_t m_pkt_24;
     cdvdfsv_rpc3_26_outpacket_t m_pkt_26;
     cdvdfsv_rpc3_27_outpacket_t m_pkt_27;
+    // OSD add
+    cdvdfsv_rpc3_28_outpacket_t m_pkt_28;
+    cdvdfsv_rpc3_29_outpacket_t m_pkt_29;
+    cdvdfsv_rpc3_2A_outpacket_t m_pkt_2A;
+    cdvdfsv_rpc3_2B_outpacket_t m_pkt_2B;
+    cdvdfsv_rpc3_2C_outpacket_t m_pkt_2C;
+    cdvdfsv_rpc3_2E_outpacket_t m_pkt_2E;
+    cdvdfsv_rpc3_2F_outpacket_t m_pkt_2F;
+    cdvdfsv_rpc3_30_outpacket_t m_pkt_30;
+    cdvdfsv_rpc3_31_outpacket_t m_pkt_31;
+    cdvdfsv_rpc3_32_outpacket_t m_pkt_32;
+    cdvdfsv_rpc3_35_outpacket_t m_pkt_35;
+    cdvdfsv_rpc3_38_outpacket_t m_pkt_38;
+    cdvdfsv_rpc3_39_outpacket_t m_pkt_39;
+    cdvdfsv_rpc3_3A_outpacket_t m_pkt_3A;
+    cdvdfsv_rpc3_3B_outpacket_t m_pkt_3B;
+    cdvdfsv_rpc3_3C_outpacket_t m_pkt_3C;
+    cdvdfsv_rpc3_3D_outpacket_t m_pkt_3D;
+    cdvdfsv_rpc3_3E_outpacket_t m_pkt_3E;
+    cdvdfsv_rpc3_3F_outpacket_t m_pkt_3F;
+    cdvdfsv_rpc3_43_outpacket_t m_pkt_43;
+    cdvdfsv_rpc3_44_outpacket_t m_pkt_44;
+    // OSD add end
 } cdvdfsv_rpc3_outpacket_t;
 
 typedef struct cdvdfsv_rpc5_01_inpacket_
@@ -274,6 +768,15 @@ typedef struct cdvdfsv_rpc5_02_inpacket_
     uiptr m_eedest;
 } cdvdfsv_rpc5_02_inpacket_t;
 
+typedef struct cdvdfsv_rpc5_03_inpacket_
+{
+    u32 m_lbn;
+    u32 m_nsectors;
+    u32 m_buf;
+    sceCdRMode m_mode;
+    u32 m_eedest;
+} cdvdfsv_rpc5_03_inpacket_t;
+
 typedef struct cdvdfsv_rpc5_04_inpacket_
 {
     uiptr m_eedest;
@@ -284,6 +787,13 @@ typedef struct cdvdfsv_rpc5_05_inpacket_
     u32 m_lbn;
 } cdvdfsv_rpc5_05_inpacket_t;
 
+typedef struct cdvdfsv_rpc5_0B_inpacket_
+{
+    u32 m_arg1;
+    u32 m_arg2;
+    u32 m_command;
+} cdvdfsv_rpc5_0B_inpacket_t;
+
 typedef struct cdvdfsv_rpc5_0C_inpacket_
 {
     u8 m_cmdNum;
@@ -313,8 +823,14 @@ typedef union cdvdfsv_rpc5_inpacket_
 {
     cdvdfsv_rpc5_01_inpacket_t m_pkt_01;
     cdvdfsv_rpc5_02_inpacket_t m_pkt_02;
+    // OSD add
+    cdvdfsv_rpc5_03_inpacket_t m_pkt_03;
+    // OSD add end
     cdvdfsv_rpc5_04_inpacket_t m_pkt_04;
     cdvdfsv_rpc5_05_inpacket_t m_pkt_05;
+    // OSD add
+    cdvdfsv_rpc5_0B_inpacket_t m_pkt_0B;
+    // OSD add end
     cdvdfsv_rpc5_0C_inpacket_t m_pkt_0C;
     cdvdfsv_rpc5_0D_inpacket_t m_pkt_0D;
     cdvdfsv_rpc5_0F_inpacket_t m_pkt_0F;
@@ -326,6 +842,12 @@ typedef struct cdvdfsv_rpc5_04_outpacket_
     int m_isdvd;
 } cdvdfsv_rpc5_04_outpacket_t;
 
+typedef struct cdvdfsv_rpc5_0B_outpacket_
+{
+    int m_retres;
+    u8 m_dg_buf[16];
+} cdvdfsv_rpc5_0B_outpacket_t;
+
 typedef struct cdvdfsv_rpc5_11_outpacket_
 {
     int m_retres;
@@ -342,6 +864,9 @@ typedef union cdvdfsv_rpc5_outpacket_
 {
     int m_retres;
     cdvdfsv_rpc5_04_outpacket_t m_pkt_04;
+    // OSD add
+    cdvdfsv_rpc5_0B_outpacket_t m_pkt_0B;
+    // OSD add end
     cdvdfsv_rpc5_11_outpacket_t m_pkt_11;
     cdvdfsv_rpc5_17_outpacket_t m_pkt_17;
 } cdvdfsv_rpc5_outpacket_t;
diff --git a/iop/cdvd/cdvdfsv/src/cdvdfsv.c b/iop/cdvd/cdvdfsv/src/cdvdfsv.c
index 6572c6a1429..f878e4985fc 100644
--- a/iop/cdvd/cdvdfsv/src/cdvdfsv.c
+++ b/iop/cdvd/cdvdfsv/src/cdvdfsv.c
@@ -19,19 +19,33 @@ IRX_ID("cdvd_ee_driver", 2, 38);
 
 extern struct irx_export_table _exp_cdvdfsv;
 
-static int cdvdfsv_init();
+static int cdvdfsv_init(void);
 static void cdvdfsv_main_th(void *arg);
-int *cdvdfsv_dummyentry(int arg1);
+extern int *cdvdfsv_dummyentry(int arg1);
 static void cdvdfsv_parseargs(int ac, char **av);
-static void cdvdfsv_poffloop();
+static void cdvdfsv_poffloop(void);
 static void cdvdfsv_rpc1_th(void *arg);
 static void cdvdfsv_rpc3_th(void *arg);
 static void cdvdfsv_rpc2_th(void *arg);
-unsigned int optimized_memcpy(char *dst, const char *src, unsigned int n);
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc4_th(void *arg);
+static void cdvdfsv_rpc5_th(void *arg);
+#endif
+extern unsigned int optimized_memcpy(char *dst, const char *src, unsigned int n);
 
 static int g_cdvdfsv_def_pri = 81;
 static int g_verbose_level = 0;
 static int g_cdvdfsv_spinctl = -1;
+// Was non-const in XOSD
+static const int g_cdvdfsv_sectors = 0x10;
+// g_cdvdfsv_sectors_cdda is same as g_cdvdfsv_sectors; separated here for reference
+#ifdef CDVD_VARIANT_OSD
+static const int g_cdvdfsv_sectors_cdda = 0x10;
+#else
+static const int g_cdvdfsv_sectors_cdda = 8;
+#endif
+// Was non-const in XOSD
+static const int g_cdvdfsv_r2retry_initval = 3;
 static int g_cdvdfsv_plbreak = 0;
 static int g_cdvdfsv_nopocm = 0;
 static int g_cdvdfsv_rpc5flg = 0;
@@ -43,7 +57,7 @@ static int g_cdvdfsv_r2retry = 0;
 static int g_cdvdfsv_r2count = 0;
 static int g_cdvdfsv_sid_err_recover_cnt = 0;
 static int g_cdvdfsv_err_count = 0;
-static void *g_cdvdfsv_fsvrbuf;
+static char *g_cdvdfsv_fsvrbuf[2];
 static char *g_cdvdfsv_rtocbuf;
 static SifDmaTransfer_t g_cdvdfsv_fssdd;
 static SifDmaTransfer_t g_cdvdfsv_iomrsdd;
@@ -53,13 +67,20 @@ static sceCdRMode g_cdvdfsv_rmodeee;
 static SifDmaTransfer_t g_cdvdfsv_datasdd;
 static SifDmaTransfer_t g_cdvdfsv_eerpsdd;
 static SifDmaTransfer_t g_cdvdfsv_chrdsdd;
+#ifdef CDVD_VARIANT_OSD
+static SifDmaTransfer_t g_cdvdfsv_readdvdv_dmat;
+#endif
 static SifDmaTransfer_t g_cdvdfsv_eereadfull_dma1;
 static SifDmaTransfer_t g_cdvdfsv_eereadfull_dma2;
 static SifDmaTransfer_t g_cdvdfsv_rtocsdd;
 static iop_sys_clock_t g_cdvdfsv_read_timeout;
-static int g_cdvdman_intr_efid;
-static int g_scmd_evid;
+static int g_cdvdman_intr_evfid;
+static int g_scmd_evfid;
+#ifdef CDVD_VARIANT_OSD
+static int g_cdvdfsv_thids[6];
+#else
 static int g_cdvdfsv_thids[4];
+#endif
 static cdvdman_internal_struct_t *g_cdvdman_istruct_ptr;
 static cdvdfsv_rpc1_outpacket_t g_cdvdfsv_initres;
 static cdvdfsv_unaligned_data_outpacket_t g_cdvdfsv_eereadx;
@@ -83,6 +104,10 @@ static int g_rpc_buffer5[256];
 static int g_rpc_buffer1[4];
 static int g_rpc_buffer4[76];
 static int g_rpc_buffer2[4];
+static int g_rpc_buffer2[4];
+#ifdef CDVD_VARIANT_OSD
+static char g_extra_fsvrbuf[40256];
+#endif
 
 static int cdvdfsv_checkdmastat(int trid)
 {
@@ -97,7 +122,7 @@ static int cdvdfsv_checkdmastat(int trid)
 	return retval;
 }
 
-static int cdvdfsv_cleanuprpc()
+static int cdvdfsv_cleanuprpc(void)
 {
 	unsigned int i;
 
@@ -152,9 +177,13 @@ int _start(int ac, char *av[], void *startaddr, ModuleInfo_t *mi)
 	{
 		return MODULE_NO_RESIDENT_END;
 	}
-	g_cdvdfsv_fsvrbuf = sceGetFsvRbuf();
-	// Unofficial: setting of unused variable removed
-	g_cdvdfsv_rtocbuf = (char *)g_cdvdfsv_fsvrbuf;
+	g_cdvdfsv_fsvrbuf[0] = (char *)sceGetFsvRbuf();
+#ifdef CDVD_VARIANT_OSD
+	g_cdvdfsv_fsvrbuf[1] = &g_extra_fsvrbuf[0];
+#endif
+	g_cdvdfsv_rtocbuf = g_cdvdfsv_fsvrbuf[0];
+	// g_cdvdfsv_sectors was set in XOSD variant
+	// g_cdvdfsv_r2retry_initval was set in XOSD variant
 	cdvdfsv_parseargs(ac, av);
 	cdvdfsv_init();
 #if 0
@@ -174,7 +203,7 @@ int _start(int ac, char *av[], void *startaddr, ModuleInfo_t *mi)
 #endif
 }
 
-static int cdvdfsv_init()
+static int cdvdfsv_init(void)
 {
 	const int *BootMode;
 	iop_thread_t thparam;
@@ -187,7 +216,7 @@ static int cdvdfsv_init()
 		return 1;
 	}
 	sceCdSC(0xFFFFFFF2, (int *)&g_cdvdman_istruct_ptr);
-	g_scmd_evid = sceCdSC(0xFFFFFFE7, &scres);
+	g_scmd_evfid = sceCdSC(0xFFFFFFE7, &scres);
 	thparam.attr = TH_C;
 	thparam.thread = cdvdfsv_main_th;
 	thparam.stacksize = 0x800;
@@ -234,6 +263,22 @@ static void cdvdfsv_main_th(void *arg)
 	thparam1.priority = g_cdvdfsv_def_pri;
 	g_cdvdfsv_thids[3] = CreateThread(&thparam1);
 	StartThread(g_cdvdfsv_thids[3], 0);
+#ifdef CDVD_VARIANT_OSD
+	thparam1.attr = TH_C;
+	thparam1.thread = cdvdfsv_rpc4_th;
+	thparam1.stacksize = 0x800;
+	thparam1.option = 0;
+	thparam1.priority = g_cdvdfsv_def_pri;
+	g_cdvdfsv_thids[4] = CreateThread(&thparam1);
+	StartThread(g_cdvdfsv_thids[4], 0);
+	thparam1.attr = TH_C;
+	thparam1.thread = cdvdfsv_rpc5_th;
+	thparam1.stacksize = 0x800;
+	thparam1.option = 0;
+	thparam1.priority = g_cdvdfsv_def_pri;
+	g_cdvdfsv_thids[5] = CreateThread(&thparam1);
+	StartThread(g_cdvdfsv_thids[5], 0);
+#endif
 	cdvdfsv_poffloop();
 	ExitDeleteThread();
 }
@@ -281,6 +326,10 @@ int sceCdChangeThreadPriority(int priority)
 	ChangeThreadPriority(g_cdvdfsv_thids[2], priority);
 	ChangeThreadPriority(g_cdvdfsv_thids[1], priority);
 	ChangeThreadPriority(g_cdvdfsv_thids[3], priority);
+#ifdef CDVD_VARIANT_OSD
+	ChangeThreadPriority(g_cdvdfsv_thids[4], priority);
+	ChangeThreadPriority(g_cdvdfsv_thids[5], priority);
+#endif
 	return 0;
 }
 
@@ -417,7 +466,7 @@ static void cdvdfsv_rpc5_0D_iopmread(const cdvdfsv_rpc5_inpacket_t *inbuf, int b
 			;
 	}
 	error_code = sceCdGetError();
-	if ( error_code || !cmd_error )
+	if ( error_code != SCECdErNO || !cmd_error )
 	{
 		if ( !cmd_error )
 			sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
@@ -430,9 +479,9 @@ static u8 cdvdfsv_syncdec(int flag, int xorkey, int arg2, u8 data)
 	return flag ? (((data << (arg2 % 8)) | (data >> (8 - arg2 % 8))) ^ xorkey) : data;
 }
 
-static int cdvdfsv_cb_read()
+static int cdvdfsv_cb_read(void)
 {
-	iSetEventFlag(g_cdvdman_intr_efid, 0x20);
+	iSetEventFlag(g_cdvdman_intr_evfid, 0x20);
 	return 0;
 }
 
@@ -484,13 +533,15 @@ static int cdvdfsv_checksid(u32 lsn, u32 sectors, u32 ps2dvd, void *buf, int dec
 		}
 		if ( readlsn != (lsn + i) || ipi_emu )
 		{
+			// The following printf was modified for ioprp300x
 			VERBOSE_PRINTF(
 				1,
-				"Read_EE Sector_ID error lsn= %d readlsn= %d layer= %d layer1_start %d\n",
+				"Read_EE Sector_ID error lsn= %d readlsn= %d layer= %d layer1_start %d ipi_emu %d\n",
 				(int)(lsn + i),
 				(int)readlsn,
 				(syncdec_4 & 1),
-				(int)(g_cdvdman_istruct_ptr->m_layer_1_lsn));
+				(int)(g_cdvdman_istruct_ptr->m_layer_1_lsn),
+				ipi_emu);
 			return 0;
 		}
 	}
@@ -537,7 +588,7 @@ static int readproc2(
 	int retry_flag2;
 	int sector_size;
 
-	error_code_tmp = 0;
+	error_code_tmp = SCECdErNO;
 	sector_sizes[0] = 0x924;
 	sector_sizes[1] = 0x810;
 	g_cdvdfsv_read_timeout.hi = 0;
@@ -547,21 +598,25 @@ static int readproc2(
 	g_cdvdfsv_r2count = 0;
 	if ( secsize != 0x924 && !fssift )
 	{
-		for ( i = 0; i < (sizeof(g_cdvdfsv_multi_dmat) / sizeof(g_cdvdfsv_multi_dmat[0])); i += 1 )
+		for ( i = 0; i < (unsigned int)g_cdvdfsv_sectors; i += 1 )
 		{
 			g_cdvdfsv_multi_dmat[i].attr = 0;
 			g_cdvdfsv_multi_dmat[i].size = secsize;
 		}
 	}
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "lsn= %d nsec= %d ee_addr= %08x fssift= %d secsize= %d\n", lsn, nsec, ee_addr, fssift, secsize);
 	sector_size = sector_sizes[sector_size_selection];
 	while ( 1 )
 	{
 		while ( 1 )
 		{
-			csec = (nsec <= (sizeof(g_cdvdfsv_multi_dmat) / sizeof(g_cdvdfsv_multi_dmat[0]))) ?
-							 nsec :
-							 (sizeof(g_cdvdfsv_multi_dmat) / sizeof(g_cdvdfsv_multi_dmat[0]));
-			nsec_div_cdvdfsv_sectors = (nsec >> 4) + (!!((nsec & 0xF)));
+			csec = (nsec <= (u32)g_cdvdfsv_sectors) ? nsec : (u32)g_cdvdfsv_sectors;
+#ifdef CDVD_VARIANT_OSD
+			if ( !g_cdvdfsv_sectors )
+				__builtin_trap();
+#endif
+			nsec_div_cdvdfsv_sectors = (nsec / g_cdvdfsv_sectors) + (!!((nsec & 0xF)));
 			retry_flag2 = 0;
 			ee_addr_tmp = ee_addr;
 			dmasize_tmp = dmasize;
@@ -577,8 +632,9 @@ static int readproc2(
 			{
 				VERBOSE_KPRINTF(1, "Rty_Read\n");
 				read_res_tmp = (sector_size_selection ? sceCdRV : sceCdRead0)(
-					(lsn >= 0x60) ? (lsn - 0x10 * g_cdvdfsv_r2retry) : (lsn + 0x10 * g_cdvdfsv_r2retry + 0x60),
-					0x10,
+					(lsn >= (u32)(6 * g_cdvdfsv_sectors)) ? (lsn - g_cdvdfsv_sectors * g_cdvdfsv_r2retry) :
+																									(lsn + g_cdvdfsv_sectors * g_cdvdfsv_r2retry + 6 * g_cdvdfsv_sectors),
+					g_cdvdfsv_sectors,
 					&g_cdvdfsv_rtocbuf[0x1248],
 					mode,
 					0,
@@ -613,7 +669,7 @@ static int readproc2(
 			sceCdSync(32);
 			if ( g_cdvdman_istruct_ptr->m_dec_mode_last_set )
 				break;
-			if ( !sceCdGetError() )
+			if ( sceCdGetError() == SCECdErNO )
 			{
 				if ( cdvdfsv_checksid(
 							 lsn + csec_comm,
@@ -775,11 +831,10 @@ static int readproc2(
 			}
 			else
 			{
-				csec_comm = csec_comm + csec;
-				csec = ((unsigned int)csec > nsec - (unsigned int)csec_comm) ?
-								 (nsec - (unsigned int)csec_comm) :
-								 (sizeof(g_cdvdfsv_multi_dmat) / sizeof(g_cdvdfsv_multi_dmat[0]));
-				ClearEventFlag(g_cdvdman_intr_efid, ~0x20);
+				csec_comm += csec;
+				csec = ((unsigned int)csec > nsec - (unsigned int)csec_comm) ? (nsec - (unsigned int)csec_comm) :
+																																			 (unsigned int)g_cdvdfsv_sectors;
+				ClearEventFlag(g_cdvdman_intr_evfid, ~0x20);
 				dmac_ch_set_chcr(3, 0);
 				dmac_ch_get_chcr(3);
 				g_cdvdman_istruct_ptr->m_dma3_param.m_dma3_maddress = &g_cdvdfsv_rtocbuf[0x1248];
@@ -806,14 +861,14 @@ static int readproc2(
 		if ( (u16)g_cdvdman_istruct_ptr->m_dec_mode_last_set )
 		{
 			retry_flag2 = 1;
-			error_code = 0;
+			error_code = SCECdErNO;
 			mode->spindlctrl = 16;
 		}
-		if ( error_code || g_cdvdfsv_r2count >= 5 )
+		if ( error_code != SCECdErNO || g_cdvdfsv_r2count >= 5 )
 			break;
 		if ( !retry_flag2 )
 		{
-			if ( !error_code_tmp )
+			if ( error_code_tmp == SCECdErNO )
 				return 1;
 			sceCdSC(0xFFFFFFFE, &error_code_tmp);
 			VERBOSE_KPRINTF(1, "secid_chk_ee_trns lsn %d nsec %d IPI Err\n", lsn, nsec);
@@ -823,10 +878,10 @@ static int readproc2(
 		{
 			g_cdvdfsv_r2count += 1;
 			VERBOSE_PRINTF(1, "Read_CD/DVD-ROM Error Recover Start\n");
-			g_cdvdfsv_r2retry = 3;
+			g_cdvdfsv_r2retry = g_cdvdfsv_r2retry_initval;
 		}
 	}
-	if ( g_cdvdfsv_r2count >= 5 && !error_code )
+	if ( g_cdvdfsv_r2count >= 5 && error_code == SCECdErNO )
 	{
 		sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
 	}
@@ -848,7 +903,7 @@ static int readproc1(
 	u32 syncdec_mask;
 	int error_code_tmp;
 
-	error_code_tmp = 0;
+	error_code_tmp = SCECdErNO;
 	g_cdvdfsv_read_timeout.hi = 0;
 	g_cdvdfsv_read_timeout.lo = 0x9000 * sceCdSC(0xFFFFFFF1, &scres_unused);
 	g_cdvdfsv_rderror = SCECdErREADCF;
@@ -879,10 +934,10 @@ static int readproc1(
 		CancelAlarm((unsigned int (*)(void *))read_timeout_alarm_cb, &g_cdvdfsv_read_timeout);
 		g_cdvdman_istruct_ptr->m_dec_state = 0;
 		error_code = sceCdGetError();
-		if ( error_code || !cmd_error || g_cdvdfsv_err_count >= 5 )
+		if ( error_code != SCECdErNO || !cmd_error || g_cdvdfsv_err_count >= 5 )
 		{
 			VERBOSE_KPRINTF(1, "Read error error code %x cmd error %d\n", error_code, cmd_error);
-			if ( (!cmd_error || g_cdvdfsv_err_count >= 5) && (!error_code) )
+			if ( (!cmd_error || g_cdvdfsv_err_count >= 5) && error_code == SCECdErNO )
 			{
 				sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
 			}
@@ -904,7 +959,7 @@ static int readproc1(
 		}
 		g_cdvdfsv_sid_err_recover_cnt -= 1;
 	}
-	if ( !error_code_tmp )
+	if ( error_code_tmp == SCECdErNO )
 		return 1;
 	sceCdSC(0xFFFFFFFE, &error_code_tmp);
 	VERBOSE_KPRINTF(1, "secid_chk lsn %d nsec %d IPI Err\n", lsn, nsec);
@@ -1255,7 +1310,8 @@ cdvdfsv_chreadee(int secoffs, int seccount, char *ee_addr, const sceCdRMode *in_
 	return 1;
 }
 
-void cdvdfsv_rpc5_0F_readchain(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+static void
+cdvdfsv_rpc5_0F_readchain(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
 {
 	int sector_size;
 	unsigned int i;
@@ -1313,7 +1369,7 @@ void cdvdfsv_rpc5_0F_readchain(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 			if ( re_result == 1 )
 			{
 				sceCdSync(0);
-				re_result = !sceCdGetError();
+				re_result = sceCdGetError() == SCECdErNO;
 			}
 			else
 			{
@@ -1322,8 +1378,9 @@ void cdvdfsv_rpc5_0F_readchain(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 		}
 		else
 		{
+			// The following printf was modified for ioprp300x
 			VERBOSE_PRINTF(
-				1, "ReadChain EE  Memory addr= 0x%08x sector= %d\n", (unsigned int)(chain[i].lbn), (int)(chain[i].sectors));
+				1, "ReadChain EE\t Memory addr= 0x%08x sector= %d\n", (unsigned int)(chain[i].lbn), (int)(chain[i].sectors));
 			// The following call to sceCdGetDiskType was inlined
 			re_result = cdvdfsv_chreadee(
 				chain[i].lbn,
@@ -1353,26 +1410,202 @@ void cdvdfsv_rpc5_0F_readchain(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 	}
 }
 
-void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc5_03_readdvdv(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+{
+	int all_sec_bytes;
+	unsigned int buf_1_toalign;
+	unsigned int buf_offs_mod_sector_size;
+	unsigned int buf_aligned;
+	u32 sectors;
+	int lbn;
+	int cmd_error;
+	int error_code;
+	unsigned int i;
+	int readbuf;
+	int cpysize;
+	int trid;
+	int state;
+	unsigned int buf_offs;
+	unsigned int buf_toalign;
+	unsigned int buf_sec_tmp;
+
+	(void)buflen;
+	error_code = SCECdErNO;
+	cmd_error = 1;
+	buf_offs = 0;
+	g_cdvdfsv_rderror = SCECdErREADCFR;
+	all_sec_bytes = 0x810 * inbuf->m_pkt_03.m_nsectors;
+	buf_toalign = ((inbuf->m_pkt_03.m_buf & 0x3F)) ? (inbuf->m_pkt_03.m_buf & ~0x3F) - (inbuf->m_pkt_03.m_buf - 0x40) : 0;
+	buf_1_toalign = (inbuf->m_pkt_03.m_buf + all_sec_bytes) & ~0x3F;
+	buf_sec_tmp = all_sec_bytes - (buf_1_toalign - inbuf->m_pkt_03.m_buf);
+	if ( buf_toalign )
+	{
+		lbn = inbuf->m_pkt_03.m_lbn + buf_offs / 0x810;
+		sectors = 1 + (!!((inbuf->m_pkt_03.m_lbn + inbuf->m_pkt_03.m_nsectors) >= (unsigned int)(lbn + 2)));
+		VERBOSE_PRINTF(1, "0 CD_READ LBN= %d sectors= %d all= %d\n", lbn, (int)sectors, (int)inbuf->m_pkt_03.m_nsectors);
+		cmd_error = sceCdReadDVDV(lbn, sectors, g_cdvdfsv_fsvrbuf[0], (sceCdRMode *)&inbuf->m_pkt_03.m_mode);
+		sceCdSync(0);
+		error_code = sceCdGetError();
+		if ( error_code != SCECdErNO || !cmd_error )
+		{
+			if ( !cmd_error )
+				sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
+			VERBOSE_PRINTF(1, "Read error code %x cmd error %d\n", error_code, cmd_error);
+			buf_toalign = 0;
+		}
+		for ( i = 0; i < buf_toalign; i += 1 )
+			g_cdvdfsv_eereadx.m_pbuf1[i] = g_cdvdfsv_fsvrbuf[0][i];
+		buf_offs += buf_toalign;
+	}
+	if ( error_code == SCECdErNO && cmd_error )
+	{
+		int firstflag;
+		unsigned int sector_count_in_bytes;
+
+		buf_offs_mod_sector_size = 0;
+		readbuf = 0;
+		firstflag = 0;
+		cpysize = 0;
+		for ( buf_aligned = inbuf->m_pkt_03.m_buf + buf_toalign; buf_aligned < buf_1_toalign;
+					buf_aligned += sector_count_in_bytes )
+		{
+			unsigned int buf_align_remain;
+
+			buf_align_remain = buf_1_toalign - buf_aligned;
+			buf_offs_mod_sector_size = (buf_aligned - inbuf->m_pkt_03.m_buf) % 0x810;
+			sector_count_in_bytes = (0x8100 >= buf_align_remain) ? buf_align_remain : 0x8100;
+			sectors = (0x8100 >= buf_align_remain) ? (buf_align_remain / 0x810 + (!!(buf_align_remain % 0x810))) : 16;
+			sectors += !!buf_offs_mod_sector_size;
+			lbn = inbuf->m_pkt_03.m_lbn + (buf_aligned - inbuf->m_pkt_03.m_buf) / 0x810;
+			if ( sectors > (inbuf->m_pkt_03.m_lbn + inbuf->m_pkt_03.m_nsectors) - lbn )
+				sectors = (inbuf->m_pkt_03.m_lbn + inbuf->m_pkt_03.m_nsectors) - lbn;
+			cmd_error = sceCdReadDVDV(lbn, sectors, g_cdvdfsv_fsvrbuf[readbuf], (sceCdRMode *)&inbuf->m_pkt_03.m_mode);
+			if ( firstflag )
+			{
+				if ( buf_offs_mod_sector_size )
+					optimized_memcpy(
+						g_cdvdfsv_fsvrbuf[readbuf ^ 1], &g_cdvdfsv_fsvrbuf[readbuf ^ 1][buf_offs_mod_sector_size], cpysize);
+				g_cdvdfsv_readdvdv_dmat.dest = (void *)(buf_aligned - cpysize);
+				g_cdvdfsv_readdvdv_dmat.size = cpysize;
+				g_cdvdfsv_readdvdv_dmat.attr = 0;
+				g_cdvdfsv_readdvdv_dmat.src = g_cdvdfsv_fsvrbuf[readbuf ^ 1];
+				while ( 1 )
+				{
+					CpuSuspendIntr(&state);
+					trid = sceSifSetDma(&g_cdvdfsv_readdvdv_dmat, 1);
+					CpuResumeIntr(state);
+					if ( trid )
+						break;
+					DelayThread(500);
+				}
+				while ( cdvdfsv_checkdmastat(trid) >= 0 )
+					;
+			}
+			sceCdSync(0);
+			error_code = sceCdGetError();
+			if ( error_code != SCECdErNO || !cmd_error )
+			{
+				if ( !cmd_error )
+					sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
+				VERBOSE_PRINTF(1, "Read error code %x cmd error %d\n", error_code, cmd_error);
+				break;
+			}
+			firstflag = 1;
+			readbuf ^= 1;
+			cpysize = sector_count_in_bytes;
+			buf_offs += sector_count_in_bytes;
+		}
+	}
+	if ( error_code == SCECdErNO && cmd_error )
+	{
+		if ( buf_offs_mod_sector_size )
+			optimized_memcpy(
+				g_cdvdfsv_fsvrbuf[readbuf ^ 1], &g_cdvdfsv_fsvrbuf[readbuf ^ 1][buf_offs_mod_sector_size], cpysize);
+		g_cdvdfsv_readdvdv_dmat.dest = (void *)buf_aligned;
+		g_cdvdfsv_readdvdv_dmat.size = cpysize;
+		g_cdvdfsv_readdvdv_dmat.attr = 0;
+		g_cdvdfsv_readdvdv_dmat.src = g_cdvdfsv_fsvrbuf[readbuf ^ 1];
+		while ( 1 )
+		{
+			CpuSuspendIntr(&state);
+			trid = sceSifSetDma(&g_cdvdfsv_readdvdv_dmat, 1);
+			CpuResumeIntr(state);
+			if ( trid )
+				break;
+			DelayThread(500);
+		}
+		while ( cdvdfsv_checkdmastat(trid) >= 0 )
+			;
+		if ( buf_sec_tmp )
+		{
+			lbn = inbuf->m_pkt_03.m_lbn + buf_offs / 0x810;
+			sectors = 1 + (!!((inbuf->m_pkt_03.m_lbn + inbuf->m_pkt_03.m_nsectors) >= (unsigned int)(lbn + 2)));
+			VERBOSE_PRINTF(1, "2 CD_READ LBN= %d sectors= %d\n", lbn, (int)sectors);
+			cmd_error = sceCdReadDVDV(lbn, sectors, g_cdvdfsv_fsvrbuf[0], (sceCdRMode *)&inbuf->m_pkt_03.m_mode);
+			sceCdSync(0);
+			error_code = sceCdGetError();
+			if ( error_code != SCECdErNO || !cmd_error )
+			{
+				if ( !cmd_error )
+					sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
+				VERBOSE_PRINTF(1, "Read error code %x cmd error %d\n", error_code, cmd_error);
+				buf_sec_tmp = 0;
+			}
+			for ( i = 0; i < buf_sec_tmp; i += 1 )
+				g_cdvdfsv_eereadx.m_pbuf2[i] = g_cdvdfsv_fsvrbuf[0][(buf_offs % 0x810) + i];
+			buf_offs += buf_sec_tmp;
+		}
+	}
+	g_cdvdfsv_eereadx.m_b1len = buf_toalign;
+	g_cdvdfsv_eereadx.m_b2len = buf_sec_tmp;
+	g_cdvdfsv_eereadx.m_b1dst = inbuf->m_pkt_03.m_buf;
+	g_cdvdfsv_eereadx.m_b2dst = buf_1_toalign;
+	g_cdvdfsv_readdvdv_dmat.src = &g_cdvdfsv_eereadx;
+	g_cdvdfsv_readdvdv_dmat.size = sizeof(g_cdvdfsv_eereadx);
+	g_cdvdfsv_readdvdv_dmat.attr = 0;
+	g_cdvdfsv_readdvdv_dmat.dest = (void *)inbuf->m_pkt_03.m_eedest;
+	while ( 1 )
+	{
+		CpuSuspendIntr(&state);
+		trid = sceSifSetDma(&g_cdvdfsv_readdvdv_dmat, 1);
+		CpuResumeIntr(state);
+		if ( trid )
+			break;
+		DelayThread(500);
+	}
+	while ( cdvdfsv_checkdmastat(trid) >= 0 )
+		;
+	VERBOSE_PRINTF(1, "read end\n");
+	outbuf->m_retres = buf_offs;
+}
+#endif
+
+// Note: in OSD variant, the do_read_full argument was added
+static void cdvdfsv_rpc5_02_readcdda(
+	const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf, int do_read_full)
 {
-	int trid1;
+	int trid;
 	unsigned int sector_size;
 	int all_sec_bytes;
 	unsigned int buf_1_toalign;
+	u32 sectors;
+	int lbn;
 	int cmd_error;
 	int error_code;
 	unsigned int i;
-	int trid2;
 	int state;
 	int error_code_tmp;
 	unsigned int buf_offs;
 	unsigned int buf_toalign;
 	unsigned int buf_sec_tmp;
-	unsigned int lbn_1_end;
 
-	trid1 = 0;
+#ifndef CDVD_VARIANT_OSD
+	(void)do_read_full;
+#endif
+	trid = 0;
 	g_cdvdfsv_rderror = SCECdErREADCFR;
-	error_code_tmp = 0;
+	error_code_tmp = SCECdErNO;
 	g_cdvdfsv_eereadfull_dma2.src = &g_cdvdfsv_readpos;
 	g_cdvdfsv_eereadfull_dma2.size = sizeof(g_cdvdfsv_readpos);
 	g_cdvdfsv_eereadfull_dma2.attr = 0;
@@ -1390,7 +1623,6 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 	}
 	buf_offs = 0;
 	all_sec_bytes = sector_size * inbuf->m_pkt_02.m_sectors;
-	lbn_1_end = inbuf->m_pkt_02.m_lbn + inbuf->m_pkt_02.m_sectors;
 	buf_toalign =
 		((inbuf->m_pkt_02.m_buf & 0x3F)) ? ((inbuf->m_pkt_02.m_buf & ~0x3F) - (inbuf->m_pkt_02.m_buf - 0x40)) : 0;
 	buf_1_toalign = (inbuf->m_pkt_02.m_buf + all_sec_bytes) & ~0x3F;
@@ -1398,21 +1630,21 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 	if ( buf_toalign )
 	{
 		unsigned int buf_offs_sectors;
-		u32 sectors_1;
 
 		buf_offs_sectors = buf_offs / sector_size;
-		sectors_1 = (lbn_1_end < inbuf->m_pkt_02.m_lbn + buf_offs / sector_size + 2) ? 1 : 2;
+		lbn = inbuf->m_pkt_02.m_lbn + buf_offs_sectors;
+		sectors = 1 + !!((inbuf->m_pkt_02.m_lbn + inbuf->m_pkt_02.m_sectors) >= (unsigned int)(lbn + 2));
 		VERBOSE_PRINTF(
-			1,
-			"0 CD_READ LBN= %d sectors= %d all= %d\n",
-			(int)(inbuf->m_pkt_02.m_lbn + buf_offs_sectors),
-			(int)sectors_1,
-			(int)inbuf->m_pkt_02.m_sectors);
-		cmd_error = sceCdReadCDDA(
-			inbuf->m_pkt_02.m_lbn + buf_offs_sectors, sectors_1, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+			1, "0 CD_READ LBN= %d sectors= %d all= %d\n", (int)lbn, (int)sectors, (int)inbuf->m_pkt_02.m_sectors);
+#ifdef CDVD_VARIANT_OSD
+		cmd_error = do_read_full ? sceCdReadFull(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode) :
+															 sceCdReadCDDA(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#else
+		cmd_error = sceCdReadCDDA(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#endif
 		sceCdSync(3);
 		error_code = sceCdGetError();
-		if ( error_code || !cmd_error )
+		if ( error_code != SCECdErNO || !cmd_error )
 		{
 			if ( !cmd_error )
 				sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
@@ -1424,7 +1656,7 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 				buf_toalign = 0;
 			}
 		}
-		if ( error_code_tmp && error_code_tmp != SCECdErEOM && error_code_tmp != SCECdErSFRMTNG )
+		if ( error_code_tmp != SCECdErNO && error_code_tmp != SCECdErEOM && error_code_tmp != SCECdErSFRMTNG )
 		{
 			for ( i = 0; i < buf_toalign; i += 1 )
 			{
@@ -1433,7 +1665,7 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 			buf_offs += buf_toalign;
 		}
 	}
-	if ( error_code_tmp && error_code_tmp != SCECdErEOM && error_code_tmp != SCECdErSFRMTNG )
+	if ( error_code_tmp != SCECdErNO && error_code_tmp != SCECdErEOM && error_code_tmp != SCECdErSFRMTNG )
 	{
 		unsigned int sector_count_in_bytes;
 		unsigned int buf_aligned;
@@ -1443,31 +1675,30 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 		{
 			unsigned int buf_align_remain;
 			unsigned int buf_offs_mod_sector_size;
-			u32 lsn_2;
-			u32 sector_count;
 
 			buf_align_remain = buf_1_toalign - buf_aligned;
 			buf_offs_mod_sector_size = buf_offs % sector_size;
-			lsn_2 = inbuf->m_pkt_02.m_lbn + buf_offs / sector_size;
-			sector_count_in_bytes = 8 * sector_size;
-			if ( sector_count_in_bytes >= buf_align_remain )
-			{
-				sector_count_in_bytes = buf_align_remain;
-				sector_count =
-					(buf_align_remain / sector_size) + (!!(buf_align_remain % sector_size)) + (!!buf_offs_mod_sector_size);
-			}
-			else
-			{
-				sector_count = 8 + (!!(buf_offs % sector_size));
-			}
-			if ( sector_count > lbn_1_end - lsn_2 )
-				sector_count = lbn_1_end - lsn_2;
-			while ( cdvdfsv_checkdmastat(trid1) >= 0 )
+			lbn = inbuf->m_pkt_02.m_lbn + buf_offs / sector_size;
+			sectors = (g_cdvdfsv_sectors_cdda * sector_size >= buf_align_remain) ?
+									(buf_align_remain / sector_size) + (!!(buf_align_remain % sector_size)) :
+									g_cdvdfsv_sectors_cdda;
+			sectors += !!buf_offs_mod_sector_size;
+			sector_count_in_bytes = (g_cdvdfsv_sectors_cdda * sector_size >= buf_align_remain) ?
+																g_cdvdfsv_sectors_cdda * sector_size :
+																buf_align_remain;
+			if ( sectors > (inbuf->m_pkt_02.m_lbn + inbuf->m_pkt_02.m_sectors) - lbn )
+				sectors = (inbuf->m_pkt_02.m_lbn + inbuf->m_pkt_02.m_sectors) - lbn;
+			while ( cdvdfsv_checkdmastat(trid) >= 0 )
 				;
-			cmd_error = sceCdReadCDDA(lsn_2, sector_count, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#ifdef CDVD_VARIANT_OSD
+			cmd_error = do_read_full ? sceCdReadFull(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode) :
+																 sceCdReadCDDA(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#else
+			cmd_error = sceCdReadCDDA(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#endif
 			sceCdSync(3);
 			error_code = sceCdGetError();
-			if ( error_code || !cmd_error )
+			if ( error_code != SCECdErNO || !cmd_error )
 			{
 				if ( !cmd_error )
 					sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
@@ -1488,9 +1719,9 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 			while ( 1 )
 			{
 				CpuSuspendIntr(&state);
-				trid1 = sceSifSetDma(&g_cdvdfsv_eereadfull_dma1, 1);
+				trid = sceSifSetDma(&g_cdvdfsv_eereadfull_dma1, 1);
 				CpuResumeIntr(state);
-				if ( trid1 )
+				if ( trid )
 					break;
 				DelayThread(500);
 			}
@@ -1503,24 +1734,27 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 			buf_offs += sector_count_in_bytes;
 		}
 	}
-	if ( (error_code_tmp && error_code_tmp != SCECdErEOM && error_code_tmp != SCECdErSFRMTNG) && buf_sec_tmp )
+	if (
+		(error_code_tmp != SCECdErNO && error_code_tmp != SCECdErEOM && error_code_tmp != SCECdErSFRMTNG) && buf_sec_tmp )
 	{
-		u32 sectors_3;
-		u32 lsn_3;
-
-		lsn_3 = inbuf->m_pkt_02.m_lbn + buf_offs / sector_size;
-		sectors_3 = (lbn_1_end < lsn_3 + 2) ? 1 : 2;
+		lbn = inbuf->m_pkt_02.m_lbn + buf_offs / sector_size;
+		sectors = 1 + !!((inbuf->m_pkt_02.m_lbn + inbuf->m_pkt_02.m_sectors) >= (unsigned int)(lbn + 2));
 		VERBOSE_PRINTF(
 			1,
 			"0 CD_READ LBN= %d sectors= %d all= %d\n",
 			(int)(inbuf->m_pkt_02.m_lbn + buf_offs / sector_size),
-			(int)sectors_3,
+			(int)sectors,
 			(int)inbuf->m_pkt_02.m_sectors);
-		VERBOSE_PRINTF(1, "2 CD_READ LBN= %d sectors= %d\n", (int)lsn_3, (int)sectors_3);
-		cmd_error = sceCdReadCDDA(lsn_3, sectors_3, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+		VERBOSE_PRINTF(1, "2 CD_READ LBN= %d sectors= %d\n", (int)lbn, (int)sectors);
+#ifdef CDVD_VARIANT_OSD
+		cmd_error = do_read_full ? sceCdReadFull(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode) :
+															 sceCdReadCDDA(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#else
+		cmd_error = sceCdReadCDDA(lbn, sectors, g_cdvdfsv_rtocbuf, (sceCdRMode *)&inbuf->m_pkt_02.m_mode);
+#endif
 		sceCdSync(3);
 		error_code = sceCdGetError();
-		if ( error_code || !cmd_error )
+		if ( error_code != SCECdErNO || !cmd_error )
 		{
 			if ( !cmd_error )
 				sceCdSC(0xFFFFFFFE, &g_cdvdfsv_rderror);
@@ -1540,7 +1774,7 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 	g_cdvdfsv_eereadx.m_b2len = buf_sec_tmp;
 	g_cdvdfsv_eereadx.m_b1dst = inbuf->m_pkt_02.m_buf;
 	g_cdvdfsv_eereadx.m_b2dst = buf_1_toalign;
-	while ( cdvdfsv_checkdmastat(trid1) >= 0 )
+	while ( cdvdfsv_checkdmastat(trid) >= 0 )
 		;
 	g_cdvdfsv_eereadfull_dma1.src = &g_cdvdfsv_eereadx;
 	g_cdvdfsv_eereadfull_dma1.size = sizeof(g_cdvdfsv_eereadx);
@@ -1550,23 +1784,23 @@ void cdvdfsv_rpc5_02_readcdda(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen,
 	while ( 1 )
 	{
 		CpuSuspendIntr(&state);
-		trid2 = sceSifSetDma(&g_cdvdfsv_eereadfull_dma1, 1);
+		trid = sceSifSetDma(&g_cdvdfsv_eereadfull_dma1, 1);
 		if ( (unsigned int)buflen >= 0x19 )
 			sceSifSetDma(&g_cdvdfsv_eereadfull_dma2, 1);
 		CpuResumeIntr(state);
-		if ( trid2 )
+		if ( trid )
 			break;
 		DelayThread(500);
 	}
-	while ( cdvdfsv_checkdmastat(trid2) >= 0 )
+	while ( cdvdfsv_checkdmastat(trid) >= 0 )
 		;
-	if ( error_code_tmp )
+	if ( error_code_tmp != SCECdErNO )
 		sceCdSC(0xFFFFFFFE, &error_code_tmp);
 	VERBOSE_PRINTF(1, "read end\n");
 	outbuf->m_retres = buf_offs;
 }
 
-void *cbrpc_rpc2_diskready(int fno, void *buffer, int length)
+static void *cbrpc_rpc2_diskready(int fno, void *buffer, int length)
 {
 	(void)fno;
 	(void)length;
@@ -1644,7 +1878,7 @@ static void cdvdfsv_rpc3_06_ri(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen,
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 		outbuf->m_retres = sceCdRI(outbuf->m_pkt_06.m_buffer, &outbuf->m_pkt_06.m_result);
 	}
 }
@@ -1660,7 +1894,7 @@ static void cdvdfsv_rpc3_1A_rm(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen,
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 		outbuf->m_retres = sceCdRM(outbuf->m_pkt_1A.m_buffer, &outbuf->m_pkt_1A.m_status);
 	}
 }
@@ -1677,7 +1911,7 @@ static void cdvdfsv_rpc3_24_readguid(const cdvdfsv_rpc3_inpacket_t *inbuf, int b
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 		outbuf->m_retres = sceCdReadGUID(&outbuf->m_pkt_24.m_guid);
 	}
 }
@@ -1694,7 +1928,7 @@ cdvdfsv_rpc3_26_readmodelid(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cd
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 		outbuf->m_retres = sceCdReadModelID(&outbuf->m_pkt_26.m_id);
 	}
 }
@@ -1708,6 +1942,15 @@ static void cdvdfsv_rpc3_22_mmode(const cdvdfsv_rpc3_inpacket_t *inbuf, int bufl
 	}
 }
 
+#ifdef CDVD_VARIANT_XOSD
+static void cdvdfsv_rpc3_2D_chgsys(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)buflen;
+	VERBOSE_KPRINTF(1, "EE call recv sceCdChgSys %d %08x\n", inbuf->m_pkt_2D.m_arg1, inbuf);
+	outbuf->m_retres = sceCdChgSys(inbuf->m_pkt_2D.m_arg1);
+}
+#endif
+
 static void
 cdvdfsv_rpc3_23_changethreadpriority(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
@@ -1716,139 +1959,916 @@ cdvdfsv_rpc3_23_changethreadpriority(const cdvdfsv_rpc3_inpacket_t *inbuf, int b
 	outbuf->m_retres = sceCdChangeThreadPriority(inbuf->m_pkt_23.m_priority);
 }
 
-static void cdvdfsv_rpc3_21_poweroff(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_07_wi(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
 	int i;
 	u32 efbits;
 
 	(void)inbuf;
 	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWI(inbuf->m_pkt_07.m_buffer, &outbuf->m_pkt_07.m_status);
+	}
+}
+#endif
 
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_1B_wm(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
-		outbuf->m_retres = sceCdPowerOff(&outbuf->m_pkt_21.m_result);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWM(inbuf->m_pkt_1B.m_buffer, &outbuf->m_pkt_1B.m_status);
 	}
 }
+#endif
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc3_15_ctrladout(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+cdvdfsv_rpc3_12_readconsoleid(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
 	int i;
 	u32 efbits;
 
+	(void)inbuf;
 	(void)buflen;
-
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
-		outbuf->m_retres = sceCdCtrlADout(inbuf->m_pkt_15.m_mode, &outbuf->m_pkt_15.m_status);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadConsoleID(outbuf->m_pkt_12.m_buffer, &outbuf->m_pkt_12.m_status);
 	}
 }
+#endif
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc3_01_readclock(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+cdvdfsv_rpc3_13_writeconsoleid(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
 	int i;
 	u32 efbits;
 
 	(void)inbuf;
 	(void)buflen;
-
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
-		outbuf->m_retres = sceCdReadClock(&outbuf->m_pkt_01.m_clock);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWriteConsoleID(inbuf->m_pkt_13.m_buffer, &outbuf->m_pkt_13.m_status);
 	}
 }
+#endif
 
-#ifdef CDVD_VARIANT_DNAS
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc5_11_readdiskid(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+cdvdfsv_rpc3_14_getmversion(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
+	int i;
+	u32 efbits;
+
 	(void)inbuf;
 	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdMV(outbuf->m_pkt_14.m_buffer, &outbuf->m_pkt_14.m_status);
+	}
+}
+#endif
 
-	outbuf->m_retres = sceCdReadDiskID((unsigned int *)&(outbuf->m_pkt_11.m_diskid));
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_17_readsubq(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadSUBQ(outbuf->m_pkt_17.m_buffer, &outbuf->m_pkt_17.m_status);
+	}
 }
+#endif
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc5_17_doesuniquekeyexist(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+cdvdfsv_rpc3_18_forbiddvdp(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
+	int i;
+	u32 efbits;
+
 	(void)inbuf;
 	(void)buflen;
-
-	outbuf->m_retres = sceCdDoesUniqueKeyExist(&outbuf->m_pkt_17.m_status);
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdForbidDVDP(&outbuf->m_pkt_18.m_status);
+	}
 }
 #endif
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc3_0B_applyscmd(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+cdvdfsv_rpc3_1C_forbidread(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
-	(void)buflen;
+	int i;
+	u32 efbits;
 
-	sceCdApplySCmd(
-		inbuf->m_pkt_0B.m_cmdNum, &inbuf->m_pkt_0B.m_inBuff, inbuf->m_pkt_0B.m_inBuffSize, &(outbuf->m_pkt_0B.m_outbuf));
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdForbidRead(&outbuf->m_pkt_1C.m_status);
+	}
 }
+#endif
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc5_0C_applyncmd(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+cdvdfsv_rpc3_1E_bootcertify(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
-	(void)buflen;
+	int i;
+	u32 efbits;
 
-	outbuf->m_retres = sceCdApplyNCmd(inbuf->m_pkt_0C.m_cmdNum, &inbuf->m_pkt_0C.m_inBuff, inbuf->m_pkt_0C.m_inBuffSize);
-	sceCdSync(2);
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdBootCertify(inbuf->m_pkt_1E.m_romname);
+	}
 }
+#endif
 
-static void cdvdfsv_rpc3_04_geterror(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_1F_cancelpoffrdy(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
+	int i;
+	u32 efbits;
+
 	(void)inbuf;
 	(void)buflen;
-
-	outbuf->m_retres = sceCdGetError();
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdCancelPOffRdy(&outbuf->m_pkt_1F.m_status);
+	}
 }
+#endif
 
-static void cdvdfsv_rpc3_05_trayreq(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+static void cdvdfsv_rpc3_21_poweroff(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
 	int i;
 	u32 efbits;
 
+	(void)inbuf;
 	(void)buflen;
 
 	outbuf->m_retres = 0;
 	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
 	{
-		WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
-		outbuf->m_retres = sceCdTrayReq(inbuf->m_pkt_05.m_param, &outbuf->m_pkt_05.m_traychk);
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdPowerOff(&outbuf->m_pkt_21.m_result);
 	}
 }
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc3_25_settimeout(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+cdvdfsv_rpc3_20_blueledctl(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
-	(void)buflen;
+	int i;
+	u32 efbits;
 
-	outbuf->m_retres = sceCdSetTimeout(inbuf->m_pkt_25.m_param, inbuf->m_pkt_25.m_timeout);
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdBlueLEDCtl(inbuf->m_pkt_20.m_control, &outbuf->m_pkt_20.m_status);
+	}
 }
+#endif
 
+#ifdef CDVD_VARIANT_OSD
 static void
-cdvdfsv_rpc3_27_readdvddualinfo(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+cdvdfsv_rpc3_1D_sc_FFFFFFF8(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
-	(void)inbuf;
 	(void)buflen;
-
-	outbuf->m_retres = sceCdReadDvdDualInfo(&outbuf->m_pkt_27.m_on_dual, &outbuf->m_pkt_27.m_layer1_start);
+	g_cdvdfsv_spinctl = inbuf->m_pkt_1D.m_spinctl;
+	outbuf->m_retres = sceCdSC(0xFFFFFFF8, &g_cdvdfsv_spinctl);
 }
+#endif
 
-static int cdvdfsv_rpc5_0E_diskready()
+static void
+cdvdfsv_rpc3_15_ctrladout(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
 {
-	int is_detecting;
-	int scres_unused;
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdCtrlADout(inbuf->m_pkt_15.m_mode, &outbuf->m_pkt_15.m_status);
+	}
+}
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_19_autoadjustctrl(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdAutoAdjustCtrl(inbuf->m_pkt_19.m_mode, &outbuf->m_pkt_19.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_29_readwakeuptime(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadWakeUpTime(
+			&outbuf->m_pkt_29.m_clock,
+			&outbuf->m_pkt_29.m_userdata,
+			&outbuf->m_pkt_29.m_wakeupreason,
+			&outbuf->m_pkt_29.m_flags);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_28_writewakeuptime(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		// Unofficial: copy to output buffer then use it
+		memcpy(&outbuf->m_pkt_28.m_clock, &inbuf->m_pkt_28.m_clock, sizeof(sceCdCLOCK));
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres =
+			sceCdWriteWakeUpTime(&outbuf->m_pkt_28.m_clock, inbuf->m_pkt_28.m_userdata, inbuf->m_pkt_28.m_flags);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_30_rcbypassctl(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdRcBypassCtl(inbuf->m_pkt_30.m_mode, &outbuf->m_pkt_30.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_32_sendscmd1d(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdSendSCmd1D(
+			(int *)&outbuf->m_pkt_32.m_arg1, &outbuf->m_pkt_32.m_arg2, &outbuf->m_pkt_32.m_arg3, &outbuf->m_pkt_32.m_arg4);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_31_remote2_7(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceRemote2_7(inbuf->m_pkt_31.m_param, &outbuf->m_pkt_31.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_38_remote2_7_get(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceRemote2_7Get(&outbuf->m_pkt_38.m_param, &outbuf->m_pkt_38.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_2A_readps1bootparam(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadPS1BootParam(outbuf->m_pkt_2A.m_out, &outbuf->m_pkt_2A.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_2B_setfanprofile(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdSetFanProfile(inbuf->m_pkt_2B.m_param, &outbuf->m_pkt_2B.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_2C_i_152(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+#if 0
+		// TODO FIXME IMPORT
+		outbuf->m_retres = cdvdman_152(&outbuf->m_pkt_2C.m_arg1, &outbuf->m_pkt_2C.m_arg2);
+#else
+		outbuf->m_retres = 1;
+#endif
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_43_readregionparams(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadRegionParams(outbuf->m_pkt_43.m_arg1, &outbuf->m_pkt_43.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_44_writeregionparams(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWriteRegionParams(
+			inbuf->m_pkt_44.m_arg1, (u32 *)inbuf->m_pkt_44.m_arg2, (u8 *)inbuf->m_pkt_44.m_arg3, &outbuf->m_pkt_44.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_2F_noticegamestart(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdNoticeGameStart(inbuf->m_pkt_2F.m_arg1, &outbuf->m_pkt_2F.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_35_setledsmode(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdSetLEDsMode(inbuf->m_pkt_35.m_param, &outbuf->m_pkt_35.m_status);
+	}
+}
+#endif
+
+static void
+cdvdfsv_rpc3_01_readclock(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadClock(&outbuf->m_pkt_01.m_clock);
+	}
+}
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_02_writeclock(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		// Unofficial: copy to output buffer then use it
+		memcpy(&outbuf->m_pkt_02.m_clock, &inbuf->m_pkt_02.m_clock, sizeof(sceCdCLOCK));
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWriteClock(&outbuf->m_pkt_02.m_clock);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_08_readnvm(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		// Unofficial: direct to outbuf
+		outbuf->m_retres = sceCdReadNVM(inbuf->m_pkt_08.m_address, &outbuf->m_pkt_08.m_data, &outbuf->m_pkt_08.m_status);
+	}
+	outbuf->m_pkt_08.m_address = inbuf->m_pkt_08.m_address;
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_09_writenvm(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWriteNVM(inbuf->m_pkt_09.m_address, inbuf->m_pkt_09.m_data, &outbuf->m_pkt_09.m_status);
+	}
+	outbuf->m_pkt_09.m_address = inbuf->m_pkt_09.m_address;
+	outbuf->m_pkt_09.m_data = inbuf->m_pkt_09.m_data;
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_0D_sethdmode(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)buflen;
+	outbuf->m_retres = sceCdSetHDMode(inbuf->m_pkt_0D.m_mode);
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void cdvdfsv_rpc3_2E_xledctl(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdXLEDCtl(
+			inbuf->m_pkt_2E.m_arg1, inbuf->m_pkt_2E.m_arg2, &outbuf->m_pkt_2E.m_result1, &outbuf->m_pkt_2E.m_result2);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_39_buzzerctl(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdBuzzerCtl(&outbuf->m_pkt_39.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_3A_resetwakeupreason(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+#if 0
+		// TODO FIXME IMPORT
+		outbuf->m_retres = sceCdResetWakeupReason((u32 *)inbuf, &outbuf->m_pkt_3A.m_arg2);
+#else
+		(void)inbuf;
+		outbuf->m_retres = 1;
+#endif
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void cdvdfsv_rpc3_3B_i_169(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+#if 0
+		// TODO FIXME IMPORT
+		outbuf->m_retres = cdvdman_169(&outbuf->m_pkt_3B.m_arg1, &outbuf->m_pkt_3B.m_arg2);
+#else
+		outbuf->m_retres = 1;
+#endif
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_3C_xbspowerctl(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdXBSPowerCtl(
+			inbuf->m_pkt_3C.m_arg1, inbuf->m_pkt_3C.m_arg2, &outbuf->m_pkt_3C.m_result1, &outbuf->m_pkt_3C.m_result2);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_3D_setmediumremoval(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdSetMediumRemoval(inbuf->m_pkt_3D.m_arg1, &outbuf->m_pkt_3D.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_3E_getmediumremoval(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdGetMediumRemoval(&outbuf->m_pkt_3E.m_result1, &outbuf->m_pkt_3E.m_result2);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_3F_xdvrpreset(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdXDVRPReset(inbuf->m_pkt_3F.m_arg1, &outbuf->m_pkt_3F.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static void
+cdvdfsv_rpc3_40_getwakeupreason(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = sceCdGetWakeUpReason();
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_0E_openconfig(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdOpenConfig(
+			inbuf->m_pkt_0E.m_block, inbuf->m_pkt_0E.m_mode, inbuf->m_pkt_0E.m_NumBlocks, &outbuf->m_pkt_0E.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_0F_closeconfig(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdCloseConfig(&outbuf->m_pkt_0F.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_10_readconfig(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)inbuf;
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdReadConfig(outbuf->m_pkt_10.m_buffer, &outbuf->m_pkt_10.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void
+cdvdfsv_rpc3_11_writeconfig(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdWriteConfig(inbuf->m_pkt_11.m_buffer, &outbuf->m_pkt_11.m_status);
+	}
+}
+#endif
+
+#ifdef CDVD_VARIANT_DNAS
+static void
+cdvdfsv_rpc5_11_readdiskid(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+{
+	(void)inbuf;
+	(void)buflen;
+
+	outbuf->m_retres = sceCdReadDiskID((unsigned int *)&(outbuf->m_pkt_11.m_diskid));
+}
+
+static void
+cdvdfsv_rpc5_17_doesuniquekeyexist(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+{
+	(void)inbuf;
+	(void)buflen;
+
+	outbuf->m_retres = sceCdDoesUniqueKeyExist(&outbuf->m_pkt_17.m_status);
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc5_0B_dg(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+{
+	(void)buflen;
+	// Unofficial: write directly to output buffer
+	outbuf->m_retres = sceCdReadKey(
+		inbuf->m_pkt_0B.m_arg1, inbuf->m_pkt_0B.m_arg2, inbuf->m_pkt_0B.m_command, (u8 *)outbuf->m_pkt_0B.m_dg_buf);
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc3_0A_decset(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)buflen;
+	outbuf->m_retres =
+		sceCdDecSet(inbuf->m_pkt_0A.m_enable_xor, inbuf->m_pkt_0A.m_enable_shift, inbuf->m_pkt_0A.m_shiftval);
+}
+#endif
+
+static void
+cdvdfsv_rpc3_0B_applyscmd(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)buflen;
+
+	sceCdApplySCmd(
+		inbuf->m_pkt_0B.m_cmdNum, &inbuf->m_pkt_0B.m_inBuff, inbuf->m_pkt_0B.m_inBuffSize, &(outbuf->m_pkt_0B.m_outbuf));
+}
+
+static void
+cdvdfsv_rpc5_0C_applyncmd(const cdvdfsv_rpc5_inpacket_t *inbuf, int buflen, cdvdfsv_rpc5_outpacket_t *outbuf)
+{
+	(void)buflen;
+
+	outbuf->m_retres = sceCdApplyNCmd(inbuf->m_pkt_0C.m_cmdNum, &inbuf->m_pkt_0C.m_inBuff, inbuf->m_pkt_0C.m_inBuffSize);
+	sceCdSync(2);
+}
+
+static void cdvdfsv_rpc3_04_geterror(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)inbuf;
+	(void)buflen;
+
+	outbuf->m_retres = sceCdGetError();
+}
+
+static void cdvdfsv_rpc3_05_trayreq(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	int i;
+	u32 efbits;
+
+	(void)buflen;
+
+	outbuf->m_retres = 0;
+	for ( i = 0; i < 3 && !outbuf->m_retres; i += 1 )
+	{
+		WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+		outbuf->m_retres = sceCdTrayReq(inbuf->m_pkt_05.m_param, &outbuf->m_pkt_05.m_traychk);
+	}
+}
+
+static void
+cdvdfsv_rpc3_25_settimeout(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)buflen;
+
+	outbuf->m_retres = sceCdSetTimeout(inbuf->m_pkt_25.m_param, inbuf->m_pkt_25.m_timeout);
+}
+
+static void
+cdvdfsv_rpc3_27_readdvddualinfo(const cdvdfsv_rpc3_inpacket_t *inbuf, int buflen, cdvdfsv_rpc3_outpacket_t *outbuf)
+{
+	(void)inbuf;
+	(void)buflen;
+
+	outbuf->m_retres = sceCdReadDvdDualInfo(&outbuf->m_pkt_27.m_on_dual, &outbuf->m_pkt_27.m_layer1_start);
+}
+
+static int cdvdfsv_rpc5_0E_diskready(void)
+{
+	int is_detecting;
+	int scres_unused;
 
 	is_detecting = 0;
+	// The following printf was added for ioprp300x
+	VERBOSE_PRINTF(1, "sceCdNcmddiskready call\n");
 	// The following call to sceCdGetDiskType was inlined
 	switch ( sceCdGetDiskType() )
 	{
@@ -1869,6 +2889,8 @@ static int cdvdfsv_rpc5_0E_diskready()
 		VERBOSE_PRINTF(1, "Drive Not Ready\n");
 		return 6;
 	}
+	// The following printf was added for ioprp300x
+	VERBOSE_PRINTF(1, "sceCdNcmddiskready call OKend\n");
 	return 2;
 }
 
@@ -1878,7 +2900,8 @@ static void *cbrpc_rpc5_cdvdncmds(int fno, void *buffer, int length)
 	int fno_1;
 
 	fno_1 = fno;
-	VERBOSE_PRINTF(1, "sce_cdvd N cmd start %d\n", fno);
+	// Note: in ioprp300x, the following was changed from printf to Kprintf
+	VERBOSE_KPRINTF(1, "sce_cdvd N cmd start %d\n", fno);
 	g_cdvdfsv_rpc5flg = 1;
 	sceCdSC(0xFFFFFFF6, &fno_1);
 	switch ( fno )
@@ -1889,8 +2912,13 @@ static void *cbrpc_rpc5_cdvdncmds(int fno, void *buffer, int length)
 				buffer, length, &g_crr, !(sceCdGetDiskType() ^ SCECdPS2DVD), !sceCdSC(0xFFFFFFFC, &scres_unused), 0);
 			break;
 		case 2:
-			cdvdfsv_rpc5_02_readcdda(buffer, length, &g_crr);
+			cdvdfsv_rpc5_02_readcdda(buffer, length, &g_crr, 0);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 3:
+			cdvdfsv_rpc5_03_readdvdv(buffer, length, &g_crr);
+			break;
+#endif
 		case 4:
 			cdvdfsv_rpc5_04_gettoc(buffer, length, &g_crr);
 			break;
@@ -1917,13 +2945,18 @@ static void *cbrpc_rpc5_cdvdncmds(int fno, void *buffer, int length)
 			sceCdSync(6);
 			break;
 		case 9:
-			if ( devctl("cdrom_stm0:", 0x4396, buffer, length, &g_crr.m_retres, 4) < 0 )
+			if ( devctl("cdrom_stm0:", 0x4396, buffer, length, &g_crr.m_retres, sizeof(g_crr.m_retres)) < 0 )
 				g_crr.m_retres = 0;
 			break;
 		case 10:
-			if ( devctl("cdrom_stm0:", 0x4398, buffer, length, &g_crr.m_retres, 4) < 0 )
+			if ( devctl("cdrom_stm0:", 0x4398, buffer, length, &g_crr.m_retres, sizeof(g_crr.m_retres)) < 0 )
 				g_crr.m_retres = 0;
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 11:
+			cdvdfsv_rpc5_0B_dg(buffer, length, &g_crr);
+			break;
+#endif
 		case 12:
 			cdvdfsv_rpc5_0C_applyncmd(buffer, length, &g_crr);
 			break;
@@ -1936,6 +2969,11 @@ static void *cbrpc_rpc5_cdvdncmds(int fno, void *buffer, int length)
 		case 15:
 			cdvdfsv_rpc5_0F_readchain(buffer, length, &g_crr);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 16:
+			cdvdfsv_rpc5_02_readcdda(buffer, length, &g_crr, 1);
+			break;
+#endif
 #ifdef CDVD_VARIANT_DNAS
 		case 17:
 			cdvdfsv_rpc5_11_readdiskid(buffer, length, &g_crr);
@@ -1959,7 +2997,8 @@ static void *cbrpc_rpc5_cdvdncmds(int fno, void *buffer, int length)
 	fno_1 = 0;
 	sceCdSC(0xFFFFFFF6, &fno_1);
 	g_cdvdfsv_rpc5flg = 0;
-	VERBOSE_PRINTF(1, "sce_cdvd N cmd end\n");
+	// Note: in ioprp300x, the following was changed from printf to Kprintf
+	VERBOSE_KPRINTF(1, "sce_cdvd N cmd end\n");
 	return (void *)&g_crr;
 }
 
@@ -1973,6 +3012,11 @@ static void *cbrpc_rpc3_cdvdscmds(int fno, void *buffer, int length)
 		case 1:
 			cdvdfsv_rpc3_01_readclock(buffer, length, &g_outbuf);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 2:
+			cdvdfsv_rpc3_02_writeclock(buffer, length, &g_outbuf);
+			break;
+#endif
 		case 3:
 			cdvdfsv_rpc3_03_disktype(buffer, length, &g_outbuf);
 			break;
@@ -1985,21 +3029,95 @@ static void *cbrpc_rpc3_cdvdscmds(int fno, void *buffer, int length)
 		case 6:
 			cdvdfsv_rpc3_06_ri(buffer, length, &g_outbuf);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		// Not in XOSD or DVD Player 3.11
+		case 7:
+			cdvdfsv_rpc3_07_wi(buffer, length, &g_outbuf);
+			break;
+		case 8:
+			cdvdfsv_rpc3_08_readnvm(buffer, length, &g_outbuf);
+			break;
+		case 9:
+			cdvdfsv_rpc3_09_writenvm(buffer, length, &g_outbuf);
+			break;
+		case 10:
+			cdvdfsv_rpc3_0A_decset(buffer, length, &g_outbuf);
+			break;
+#endif
 		case 11:
 			cdvdfsv_rpc3_0B_applyscmd(buffer, length, &g_outbuf);
 			break;
 		case 12:
 			cdvdfsv_rpc3_0C_cdstatus(buffer, length, &g_outbuf);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 13:
+			cdvdfsv_rpc3_0D_sethdmode(buffer, length, &g_outbuf);
+			break;
+		case 14:
+			cdvdfsv_rpc3_0E_openconfig(buffer, length, &g_outbuf);
+			break;
+		case 15:
+			cdvdfsv_rpc3_0F_closeconfig(buffer, length, &g_outbuf);
+			break;
+		case 16:
+			cdvdfsv_rpc3_10_readconfig(buffer, length, &g_outbuf);
+			break;
+		case 17:
+			cdvdfsv_rpc3_11_writeconfig(buffer, length, &g_outbuf);
+			break;
+		case 18:
+			cdvdfsv_rpc3_12_readconsoleid(buffer, length, &g_outbuf);
+			break;
+		// Not in XOSD or DVD Player 3.11
+		case 19:
+			cdvdfsv_rpc3_13_writeconsoleid(buffer, length, &g_outbuf);
+			break;
+		case 20:
+			cdvdfsv_rpc3_14_getmversion(buffer, length, &g_outbuf);
+			break;
+#endif
 		case 21:
 			cdvdfsv_rpc3_15_ctrladout(buffer, length, &g_outbuf);
 			break;
 		case 22:
 			cdvdfsv_rpc3_16_break(buffer, length, &g_outbuf);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 23:
+			cdvdfsv_rpc3_17_readsubq(buffer, length, &g_outbuf);
+			break;
+		case 24:
+			cdvdfsv_rpc3_18_forbiddvdp(buffer, length, &g_outbuf);
+			break;
+		case 25:
+			cdvdfsv_rpc3_19_autoadjustctrl(buffer, length, &g_outbuf);
+			break;
+#endif
 		case 26:
 			cdvdfsv_rpc3_1A_rm(buffer, length, &g_outbuf);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		// Not in XOSD or DVD Player 3.11
+		case 27:
+			cdvdfsv_rpc3_1B_wm(buffer, length, &g_outbuf);
+			break;
+		case 28:
+			cdvdfsv_rpc3_1C_forbidread(buffer, length, &g_outbuf);
+			break;
+		case 29:
+			cdvdfsv_rpc3_1D_sc_FFFFFFF8(buffer, length, &g_outbuf);
+			break;
+		case 30:
+			cdvdfsv_rpc3_1E_bootcertify(buffer, length, &g_outbuf);
+			break;
+		case 31:
+			cdvdfsv_rpc3_1F_cancelpoffrdy(buffer, length, &g_outbuf);
+			break;
+		case 32:
+			cdvdfsv_rpc3_20_blueledctl(buffer, length, &g_outbuf);
+			break;
+#endif
 		case 33:
 			cdvdfsv_rpc3_21_poweroff(buffer, length, &g_outbuf);
 			break;
@@ -2025,6 +3143,86 @@ static void *cbrpc_rpc3_cdvdscmds(int fno, void *buffer, int length)
 		case 39:
 			cdvdfsv_rpc3_27_readdvddualinfo(buffer, length, &g_outbuf);
 			break;
+#ifdef CDVD_VARIANT_OSD
+		case 40:
+			cdvdfsv_rpc3_28_writewakeuptime(buffer, length, &g_outbuf);
+			break;
+		case 41:
+			cdvdfsv_rpc3_29_readwakeuptime(buffer, length, &g_outbuf);
+			break;
+		case 42:
+			cdvdfsv_rpc3_2A_readps1bootparam(buffer, length, &g_outbuf);
+			break;
+		case 43:
+			cdvdfsv_rpc3_2B_setfanprofile(buffer, length, &g_outbuf);
+			break;
+		case 44:
+			cdvdfsv_rpc3_2C_i_152(buffer, length, &g_outbuf);
+			break;
+#endif
+#ifdef CDVD_VARIANT_XOSD
+		case 45:
+			cdvdfsv_rpc3_2D_chgsys(buffer, length, &g_outbuf);
+			break;
+		case 46:
+			cdvdfsv_rpc3_2E_xledctl(buffer, length, &g_outbuf);
+			break;
+		case 47:
+			cdvdfsv_rpc3_2F_noticegamestart(buffer, length, &g_outbuf);
+			break;
+#endif
+#ifdef CDVD_VARIANT_OSD
+		case 48:
+			cdvdfsv_rpc3_30_rcbypassctl(buffer, length, &g_outbuf);
+			break;
+		case 49:
+			cdvdfsv_rpc3_31_remote2_7(buffer, length, &g_outbuf);
+			break;
+		case 50:
+			cdvdfsv_rpc3_32_sendscmd1d(buffer, length, &g_outbuf);
+			break;
+		case 53:
+			cdvdfsv_rpc3_35_setledsmode(buffer, length, &g_outbuf);
+			break;
+		case 56:
+			cdvdfsv_rpc3_38_remote2_7_get(buffer, length, &g_outbuf);
+			break;
+#endif
+#ifdef CDVD_VARIANT_XOSD
+		case 57:
+			cdvdfsv_rpc3_39_buzzerctl(buffer, length, &g_outbuf);
+			break;
+		case 58:
+			cdvdfsv_rpc3_3A_resetwakeupreason(buffer, length, &g_outbuf);
+			break;
+		case 59:
+			cdvdfsv_rpc3_3B_i_169(buffer, length, &g_outbuf);
+			break;
+		case 60:
+			cdvdfsv_rpc3_3C_xbspowerctl(buffer, length, &g_outbuf);
+			break;
+		case 61:
+			cdvdfsv_rpc3_3D_setmediumremoval(buffer, length, &g_outbuf);
+			break;
+		case 62:
+			cdvdfsv_rpc3_3E_getmediumremoval(buffer, length, &g_outbuf);
+			break;
+		case 63:
+			cdvdfsv_rpc3_3F_xdvrpreset(buffer, length, &g_outbuf);
+			break;
+		case 64:
+			cdvdfsv_rpc3_40_getwakeupreason(buffer, length, &g_outbuf);
+			break;
+#endif
+#ifdef CDVD_VARIANT_OSD
+		case 67:
+			cdvdfsv_rpc3_43_readregionparams(buffer, length, &g_outbuf);
+			break;
+		// Not in XOSD or DVD Player 3.11
+		case 68:
+			cdvdfsv_rpc3_44_writeregionparams(buffer, length, &g_outbuf);
+			break;
+#endif
 		default:
 			VERBOSE_PRINTF(1, "sce_cdvd block IO :unrecognized code 0x%02x\n", fno);
 			g_outbuf.m_retres = 0;
@@ -2035,18 +3233,18 @@ static void *cbrpc_rpc3_cdvdscmds(int fno, void *buffer, int length)
 	return (void *)&g_outbuf;
 }
 
-static void cdvdfsv_poffloop()
+static void cdvdfsv_poffloop(void)
 {
 	int trid;
 	char cmdpkt[16];
 	int scres;
 	u32 efbits;
 
-	g_cdvdman_intr_efid = sceCdSC(0xFFFFFFF5, &scres);
+	g_cdvdman_intr_evfid = sceCdSC(0xFFFFFFF5, &scres);
 	while ( 1 )
 	{
-		ClearEventFlag(g_cdvdman_intr_efid, ~4);
-		WaitEventFlag(g_cdvdman_intr_efid, 4, WEF_AND, &efbits);
+		ClearEventFlag(g_cdvdman_intr_evfid, ~4);
+		WaitEventFlag(g_cdvdman_intr_evfid, 4, WEF_AND, &efbits);
 		if ( g_cdvdfsv_nopocm )
 			break;
 		if ( !g_cdvdfsv_plbreak )
@@ -2064,6 +3262,72 @@ static void cdvdfsv_poffloop()
 	}
 }
 
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc4_th(void *arg)
+{
+	int trid;
+	char cmdpkt[16];
+	int scres;
+	u32 efbits;
+
+	(void)arg;
+	g_cdvdman_intr_evfid = sceCdSC(0xFFFFFFF5, &scres);
+	while ( 1 )
+	{
+		ClearEventFlag(g_cdvdman_intr_evfid, ~0x40);
+		WaitEventFlag(g_cdvdman_intr_evfid, 0x40, WEF_AND, &efbits);
+		if ( g_cdvdfsv_nopocm )
+			break;
+		if ( !g_cdvdfsv_plbreak )
+		{
+			while ( 1 )
+			{
+				trid = sceSifSendCmd(0x80000015, cmdpkt, sizeof(cmdpkt), 0, 0, 0);
+				if ( trid )
+					break;
+				DelayThread(500);
+			}
+			while ( cdvdfsv_checkdmastat(trid) >= 0 )
+				;
+		}
+	}
+	ExitDeleteThread();
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+static void cdvdfsv_rpc5_th(void *arg)
+{
+	int trid;
+	char cmdpkt[16];
+	int scres;
+	u32 efbits;
+
+	(void)arg;
+	g_cdvdman_intr_evfid = sceCdSC(0xFFFFFFF5, &scres);
+	while ( 1 )
+	{
+		ClearEventFlag(g_cdvdman_intr_evfid, ~0x80);
+		WaitEventFlag(g_cdvdman_intr_evfid, 0x80, WEF_AND, &efbits);
+		if ( g_cdvdfsv_nopocm )
+			break;
+		if ( !g_cdvdfsv_plbreak )
+		{
+			while ( 1 )
+			{
+				trid = sceSifSendCmd(0x80000016, cmdpkt, sizeof(cmdpkt), 0, 0, 0);
+				if ( trid )
+					break;
+				DelayThread(500);
+			}
+			while ( cdvdfsv_checkdmastat(trid) >= 0 )
+				;
+		}
+	}
+	ExitDeleteThread();
+}
+#endif
+
 static void cdvdfsv_rpc1_th(void *arg)
 {
 	(void)arg;
diff --git a/iop/cdvd/cdvdman/include/cdvdman.h b/iop/cdvd/cdvdman/include/cdvdman.h
index a0e72221aea..0286c547883 100644
--- a/iop/cdvd/cdvdman/include/cdvdman.h
+++ b/iop/cdvd/cdvdman/include/cdvdman.h
@@ -113,8 +113,26 @@ typedef struct cdvdman_internal_struct_
 	u16 m_dec_mode_set;
 	u16 m_dec_mode_last_set;
 	int m_waf_set_test;
+	// OSD add
+	int m_cd_mode_ps2_atapi;
+	void (*m_cd_atapi_intr_callback)(int writer_drive);
+	int (*m_chgsys_callback)(void *userdata, int writer_drive);
+	int m_chgsys_callback_next_disktype;
+	int m_unusedosd1;
+	int m_field_0DC;
+	int m_var_sc_ffffffdb;
+	// OSD add end
 	int m_interupt_read_state;
+	// OSD add
+	int m_atapi_disk_ejected;
+	// OSD add end
 	int m_cd_inited;
+	// OSD add
+	int m_medium_removal_state;
+	int m_chgsys_callback_next_disktype_last;
+	int m_chgsys_writer_drive_shell_is_open;
+	int m_unusedosd2[6];
+	// OSD add end
 	int m_tray_is_open;
 	int m_break_cdvdfsv_readchain;
 	int m_unused[10];
diff --git a/iop/cdvd/cdvdman/src/cdvdman.c b/iop/cdvd/cdvdman/src/cdvdman.c
index a9dff330cbd..32e1adf1e23 100644
--- a/iop/cdvd/cdvdman/src/cdvdman.c
+++ b/iop/cdvd/cdvdman/src/cdvdman.c
@@ -9,6 +9,7 @@
 */
 
 #include "irx_imports.h"
+
 #include "iomanX.h"
 
 #include <cdvdman.h>
@@ -17,6 +18,7 @@
 #include <dev5_mmio_hwport.h>
 #include <errno.h>
 #include <hdd-ioctl.h>
+#include <iop_mmio_hwport.h>
 #include <kerr.h>
 
 IRX_ID("cdvd_driver", 2, 38);
@@ -24,6 +26,19 @@ IRX_ID("cdvd_driver", 2, 38);
 
 extern struct irx_export_table _exp_cdvdman;
 
+#ifdef CDVD_VARIANT_OSD
+#define PRID $15
+
+#define _mfc0(reg)                                                                                                     \
+	({                                                                                                                   \
+		u32 val;                                                                                                           \
+		__asm__ volatile("mfc0 %0, " #reg : "=r"(val));                                                                    \
+		val;                                                                                                               \
+	})
+
+#define mfc0(reg) _mfc0(reg)
+#endif
+
 typedef struct cdvdman_dirtbl_entry_
 {
 	int m_number;
@@ -155,7 +170,7 @@ typedef struct iso9660_dirent_
 } iso9660_dirent_t;
 
 static int cdrom_init(iop_device_t *dev);
-void cdvdman_termcall(int with_stop);
+extern void cdvdman_termcall(int with_stop);
 static int cdrom_deinit(iop_device_t *dev);
 static int cdrom_dopen(iop_file_t *f, const char *dirname);
 static int cdrom_getstat(iop_file_t *f, const char *name, iox_stat_t *buf);
@@ -177,7 +192,7 @@ static int cdvdman_finddir(int target_parent, const char *target_name);
 static int CD_cachefile(int dsec, int layer);
 static int disc_read(int size, int loc, void *buffer, int layer);
 static int path_tbl_init(u32 blocks, char *fname, int action);
-unsigned int optimized_memcpy(char *dst, const char *src, unsigned int n);
+extern unsigned int optimized_memcpy(char *dst, const char *src, unsigned int n);
 static int vSetAlarm(iop_sys_clock_t *sys_clock, unsigned int (*alarm_cb)(void *), void *arg);
 static int vCancelAlarm(unsigned int (*alarm_cb)(void *), void *arg);
 static int vSetEventFlag(int ef, u32 bits);
@@ -185,20 +200,35 @@ static int vDelayThread(int usec);
 static int DvdDual_infochk();
 static void cdvdman_init();
 static void cdvdman_write_scmd(cdvdman_internal_struct_t *s);
-static int intrh_dma_3(cdvdman_internal_struct_t *s);
+static int intrh_dma_3(void *userdata);
 static int cdvdman_mediactl(int code);
+#ifndef CDVD_VARIANT_XOSD
 static int cdvdman_ncmd_sender_06();
+#endif
 static int cdvdman_gettoc(u8 *toc);
 static int cdvdman_isdvd();
 static int sceCdRead0_Rty(u32 lsn, u32 nsec, void *buf, const sceCdRMode *mode, int ncmd, int dintrsec, void *func);
 static int cdvdman_syncdec(int decflag, int decxor, int shift, u32 data);
 static void Read2intrCDVD(int read2_flag);
-static int sceCdGetMVersion(u8 *buffer, u32 *status);
-static int cdvdman_scmd_sender_03_48(u8 *buf, u32 *status);
+#ifndef CDVD_VARIANT_XOSD
+static int cdvdman_scmd_sender_03_30(u8 *buf, u32 *status);
+#endif
 static int cdvdman_scmd_sender_3B(int arg1);
 #ifdef CDVD_VARIANT_DNAS
 static int cdvdman_ncmd_sender_0C(int arg1, u32 arg2, u32 arg3);
 #endif
+#ifdef CDVD_VARIANT_XOSD
+static unsigned int sceCdChgSpdlCtrl(int mode);
+#endif
+#ifdef CDVD_VARIANT_XOSD
+static int cdvdman_change_drive(int mode);
+static int cdvdman_get_renewal_date(u8 *buffer, u32 *status);
+static int get_cdvd_register(int regnr);
+static int get_disk_type_ex();
+static int sc_ffffffd8(u32 *status);
+static int set_cdvd_dev5_base_addr_atapi(int mode);
+static int update_cd_mode_ps2_atapi(void);
+#endif
 
 static char g_cdvdman_cache_name[256] = "host0:";
 static int g_cdvdman_cache_sector_size_count = 1;
@@ -214,33 +244,33 @@ static int g_cdvdman_strmerr = 0;
 IOMANX_RETURN_VALUE_IMPL(EIO);
 
 static iop_device_ops_t g_cdvdman_cddev_ops = {
-	&cdrom_init, // init,
-	&cdrom_deinit, // deinit,
-	IOMANX_RETURN_VALUE(EIO), // format,
-	&cdrom_open, // open,
-	&cdrom_close, // close,
-	&cdrom_read, // read,
-	IOMANX_RETURN_VALUE(EIO), // write,
-	&cdrom_lseek, // lseek,
-	&cdrom_ioctl, // ioctl,
-	IOMANX_RETURN_VALUE(EIO), // remove,
-	IOMANX_RETURN_VALUE(EIO), // mkdir,
-	IOMANX_RETURN_VALUE(EIO), // rmdir,
-	&cdrom_dopen, // dopen,
-	&cdrom_close, // close,
-	&cdrom_dread, // dread
-	&cdrom_getstat, // getstat
-	IOMANX_RETURN_VALUE(EIO), // chstat,
-	IOMANX_RETURN_VALUE(EIO), // rename,
-	IOMANX_RETURN_VALUE(EIO), // chdir
-	IOMANX_RETURN_VALUE(EIO), // sync
-	IOMANX_RETURN_VALUE(EIO), // mount,
-	IOMANX_RETURN_VALUE(EIO), // umount,
-	IOMANX_RETURN_VALUE_S64(EIO), // lseek64,
-	&cdrom_devctl, // devctl,
-	IOMANX_RETURN_VALUE(EIO), // readdir,
-	IOMANX_RETURN_VALUE(EIO), // readlink,
-	&cdrom_ioctl2, // ioctl2,
+	&cdrom_init,                   // init,
+	&cdrom_deinit,                 // deinit,
+	IOMANX_RETURN_VALUE(EIO),      // format,
+	&cdrom_open,                   // open,
+	&cdrom_close,                  // close,
+	&cdrom_read,                   // read,
+	IOMANX_RETURN_VALUE(EIO),      // write,
+	&cdrom_lseek,                  // lseek,
+	&cdrom_ioctl,                  // ioctl,
+	IOMANX_RETURN_VALUE(EIO),      // remove,
+	IOMANX_RETURN_VALUE(EIO),      // mkdir,
+	IOMANX_RETURN_VALUE(EIO),      // rmdir,
+	&cdrom_dopen,                  // dopen,
+	&cdrom_close,                  // close,
+	&cdrom_dread,                  // dread
+	&cdrom_getstat,                // getstat
+	IOMANX_RETURN_VALUE(EIO),      // chstat,
+	IOMANX_RETURN_VALUE(EIO),      // rename,
+	IOMANX_RETURN_VALUE(EIO),      // chdir
+	IOMANX_RETURN_VALUE(EIO),      // sync
+	IOMANX_RETURN_VALUE(EIO),      // mount,
+	IOMANX_RETURN_VALUE(EIO),      // umount,
+	IOMANX_RETURN_VALUE_S64(EIO),  // lseek64,
+	&cdrom_devctl,                 // devctl,
+	IOMANX_RETURN_VALUE(EIO),      // readdir,
+	IOMANX_RETURN_VALUE(EIO),      // readlink,
+	&cdrom_ioctl2,                 // ioctl2,
 };
 static iop_device_t g_cdvdman_cddev = {"cdrom", IOP_DT_FSEXT | IOP_DT_FS, 1, "CD-ROM ", &g_cdvdman_cddev_ops};
 static int g_cdvdman_sync_timeout = 15000;
@@ -259,6 +289,16 @@ static int g_cdvdman_fs_cdsec = 0;
 static int g_cdvdman_fs_layer = -1;
 static int g_cdvdman_fs_cache = 0;
 static int g_cdvdman_fs_base2 = 0;
+#ifdef CDVD_VARIANT_XOSD
+static vu8 *g_cdvdreg_bf801460 = (vu8 *)0xBF801460;  // &iop_mmio_hwport->dev9c[0]
+// static u8 *cdvdreg_bf801462 = 0xBF801462;
+static vu8 *g_cdvdreg_bf801464 = (vu8 *)0xBF801464;  // &iop_mmio_hwport->dev9c[4]
+static vu8 *g_cdvdreg_bf80146c = (vu8 *)0xBF80146C;  // &iop_mmio_hwport->dev9c[0xC]
+// static u8 *cdvdreg_bf80146e = 0xBF80146E;
+static int g_cd_atapi_evfid = 0xFFFFFFFF;
+static int g_acmd_evfid = 0xFFFFFFFF;
+static int g_adma_evfid = 0xFFFFFFFF;
+#endif
 static int g_cdvdman_clk_flg = 0;
 static int g_cdvdman_cd36key = 0;
 static int g_cdvdman_ee_rpc_fno = 0;
@@ -275,25 +315,46 @@ static int g_cdvdman_minver_50400 = 0;
 static int g_cdvdman_minver_50600 = 0;
 static int g_cdvdman_minver_60000 = 0;
 static int g_cdvdman_minver_60200 = 0;
+#ifdef CDVD_VARIANT_OSD
+static int g_cdvdman_minver_60600 = 0;
+#endif
+#ifdef CDVD_VARIANT_XOSD
+static int g_cdvdman_vernotxxx1x = 0;
+#endif
 static int g_cdvdman_minver_x_model_15 = 0;
-static char *g_masterdisc_header = "PlayStation Master Disc";
-static char g_cdvdman_ncmd = 6;
+#ifdef CDVD_VARIANT_XOSD
+static int g_cdvdman_debug_atapi_intr = 0;
+#endif
+static const char *g_masterdisc_header = "PlayStation Master Disc";
+static char g_cdvdman_ncmd = 0x06;
 static int g_cdvdman_chmedia = 0;
 static int g_cdvdman_chflags[4] = {1, 1, 1, 1};
 static int g_cdvdman_rtindex = 0;
 static int g_cdvdman_retries = 0;
 static u8 *g_cdvdman_ptoc;
-static int g_scmd_evid;
+#ifdef CDVD_VARIANT_XOSD
+static int g_cdvdman_csys_evfid;
+#endif
+static int g_scmd_evfid;
 static void *g_cdvdman_temp_buffer_ptr;
-static int g_sfile_evid;
-static int g_ncmd_evid;
-static int g_fio_fsv_evid;
-static int g_cdvdman_intr_efid;
+static int g_sfile_evfid;
+static int g_ncmd_evfid;
+#ifdef CDVD_VARIANT_OSD
+static s32 g_cdvdman_apply_scmd_sema;
+#endif
+static int g_fio_fsv_evfid;
+static int g_cdvdman_intr_evfid;
+#ifdef CDVD_VARIANT_XOSD
+static int (*g_cdvdman_atapi_eject_bs_power_callback)(int interrupt_nr, void *userdata);
+#endif
 static sceCdCBFunc g_cdvdman_user_cb;
-static void *g_cdvdman_poffarg;
+static void *g_cdvdman_power_off_callback_userdata;
 static void (*g_cdvdman_cdstm0cb)(int);
 static sceCdCLOCK g_cdvdman_clock;
-static void (*g_cdvdman_poff_cb)(void *userdata);
+static void (*g_cdvdman_power_off_callback)(void *userdata);
+#ifdef CDVD_VARIANT_XOSD
+static void *g_cdvdman_atapi_eject_bs_power_callback_userdata;
+#endif
 static void (*g_cdvdman_cdstm1cb)(int);
 static int g_cdvdman_cmdfunc;
 static cdvdman_fhinfo_t g_cdvdman_fhinfo[16];
@@ -301,14 +362,18 @@ static char g_cdvdman_sfname[1024];
 static cdvdman_filetbl_entry_t g_cdvdman_filetbl[64];
 static cdvdman_dirtbl_entry_t g_cdvdman_dirtbl[128];
 static int g_cdvdman_pathtblflag;
-static char g_cdvdman_fs_rbuf[2048];
+static char g_cdvdman_fs_rbuf[0x800];
 static int g_cdvdman_readptr;
 static iop_sys_clock_t g_cdvdman_read_alarm_cb_timeout;
 static iop_sys_clock_t g_cdvdman_ncmd_timeout;
 static void *g_cdvdman_readbuf;
 static iop_sys_clock_t g_cdvdman_power_off_timeout;
+#ifdef CDVD_VARIANT_OSD
+static int g_cdvdman_config_numblocks;
+#endif
 static char g_cdvdman_fsvrbuf[42128];
 static cdvdman_internal_struct_t g_cdvdman_istruct;
+static const int g_cdvdman_cache_sector_count = 16;
 
 int _start(int ac, char **av)
 {
@@ -347,6 +412,12 @@ static int cdrom_init(iop_device_t *dev)
 {
 	unsigned int i;
 	iop_event_t event;
+#ifdef CDVD_VARIANT_OSD
+	iop_sema_t sema;
+#endif
+#ifdef CDVD_VARIANT_XOSD
+	USE_DEV5_MMIO_HWPORT();
+#endif
 	int scres_unused;
 
 	(void)dev;
@@ -356,7 +427,7 @@ static int cdrom_init(iop_device_t *dev)
 	g_cdvdman_istruct.m_scmd_flag = 1;
 	g_cdvdman_istruct.m_read2_flag = 0;
 	g_cdvdman_istruct.m_stream_flag = 0;
-	g_cdvdman_istruct.m_last_error = 0;
+	g_cdvdman_istruct.m_last_error = SCECdErNO;
 	g_cdvdman_istruct.m_layer_1_lsn = 0;
 	g_cdvdman_istruct.m_use_toc = 0;
 	g_cdvdman_istruct.m_last_read_timeout = 0;
@@ -368,25 +439,45 @@ static int cdrom_init(iop_device_t *dev)
 	g_cdvdman_istruct.m_dec_shift = 0;
 	g_cdvdman_istruct.m_opo_or_para = -1;
 	g_cdvdman_istruct.m_no_dec_flag = 0;
+#ifdef CDVD_VARIANT_XOSD
+	g_cdvdman_istruct.m_atapi_disk_ejected = 0;
+#endif
 	g_cdvdman_istruct.m_cd_inited = 0;
+#ifdef CDVD_VARIANT_XOSD
+	g_cdvdman_istruct.m_chgsys_callback_next_disktype_last = 0;
+	g_cdvdman_istruct.m_chgsys_writer_drive_shell_is_open = 1;
+#endif
 	g_cdvdman_istruct.m_tray_is_open = 0;
 	g_cdvdman_ee_rpc_fno = 0;
 	g_cdvdman_spinctl = -1;
 	event.attr = EA_MULTI;
 	event.bits = 0;
 	event.option = 0;
-	g_cdvdman_intr_efid = CreateEventFlag(&event);
-	g_scmd_evid = CreateEventFlag(&event);
-	g_ncmd_evid = CreateEventFlag(&event);
-	g_sfile_evid = CreateEventFlag(&event);
-	g_fio_fsv_evid = CreateEventFlag(&event);
-	ClearEventFlag(g_cdvdman_intr_efid, ~0x4);
-	ClearEventFlag(g_cdvdman_intr_efid, ~0x10);
-	SetEventFlag(g_cdvdman_intr_efid, 0x29);
-	SetEventFlag(g_ncmd_evid, 1);
-	SetEventFlag(g_scmd_evid, 1);
-	SetEventFlag(g_sfile_evid, 1);
-	SetEventFlag(g_fio_fsv_evid, 1);
+	g_cdvdman_intr_evfid = CreateEventFlag(&event);
+	g_scmd_evfid = CreateEventFlag(&event);
+	g_ncmd_evfid = CreateEventFlag(&event);
+	g_sfile_evfid = CreateEventFlag(&event);
+	g_fio_fsv_evfid = CreateEventFlag(&event);
+#ifdef CDVD_VARIANT_XOSD
+	g_cdvdman_csys_evfid = CreateEventFlag(&event);
+#endif
+	ClearEventFlag(g_cdvdman_intr_evfid, ~0x4);
+	ClearEventFlag(g_cdvdman_intr_evfid, ~0x10);
+	SetEventFlag(g_cdvdman_intr_evfid, 0x29);
+	SetEventFlag(g_ncmd_evfid, 1);
+	SetEventFlag(g_scmd_evfid, 1);
+	SetEventFlag(g_sfile_evfid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
+#ifdef CDVD_VARIANT_XOSD
+	SetEventFlag(g_cdvdman_csys_evfid, 1);
+#endif
+#ifdef CDVD_VARIANT_OSD
+	sema.attr = 1;
+	sema.initial = 1;
+	sema.max = 1;
+	sema.option = 0;
+	g_cdvdman_apply_scmd_sema = CreateSema(&sema);
+#endif
 	g_cdvdman_spinnom = -1;
 	g_cdvdman_trycnt = -1;
 	sceCdSC(0xFFFFFFF3, &scres_unused);
@@ -394,6 +485,21 @@ static int cdrom_init(iop_device_t *dev)
 	{
 		g_cdvdman_fhinfo[i].m_fd_flags = 0;
 	}
+#ifdef CDVD_VARIANT_XOSD
+	set_cdvd_dev5_base_addr_atapi(2);
+
+	for ( i = 0; i < 600 && !dev5_mmio_hwport->m_dev5_reg_015; i += 1 )
+	{
+		DelayThread(16000);
+	}
+	g_cdvdman_istruct.m_cd_mode_ps2_atapi =
+		(!(dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen) && !(dev5_mmio_hwport->m_dev5_reg_015 & 0x80)
+		 && dev5_mmio_hwport->m_dev5_reg_00F != 6) ?
+			2 :
+			1;
+	KPRINTF("Mode %s Drive\n", g_cdvdman_istruct.m_cd_mode_ps2_atapi == 1 ? "Atapi" : "PS2");
+	set_cdvd_dev5_base_addr_atapi(g_cdvdman_istruct.m_cd_mode_ps2_atapi);
+#endif
 	return 0;
 }
 
@@ -404,22 +510,26 @@ void cdvdman_termcall(int with_stop)
 	USE_DEV5_MMIO_HWPORT();
 
 	VERBOSE_KPRINTF(1, "CDVD:library Terminate Call %d\n", with_stop);
+#ifdef CDVD_VARIANT_XOSD
+	if ( update_cd_mode_ps2_atapi() == 1 )
+	{
+		set_cdvd_dev5_base_addr_atapi(2);
+	}
+#endif
 	if ( with_stop )
 	{
 		return;
 	}
 	sceCdBreak();
 	sceCdSync(0);
+#ifndef CDVD_VARIANT_XOSD
 	if ( g_cdvdman_istruct.m_cd_inited )
 	{
 		cdvdman_ncmd_sender_06();
 	}
-	for ( i = 0; i < 50000; i += 1 )
+#endif
+	for ( i = 0; i < 50000 && (dev5_mmio_hwport->m_dev5_reg_017 & 0x80); i += 1 )
 	{
-		if ( !(dev5_mmio_hwport->m_dev5_reg_017 & 0x80) )
-		{
-			break;
-		}
 		DelayThread(100);
 	}
 	sceCdDecSet(0, 0, 0);
@@ -444,27 +554,31 @@ static int cdrom_deinit(iop_device_t *dev)
 	{
 		g_cdvdman_fhinfo[i].m_fd_flags = 0;
 	}
-	DeleteEventFlag(g_fio_fsv_evid);
-	DeleteEventFlag(g_cdvdman_intr_efid);
-	DeleteEventFlag(g_ncmd_evid);
-	DeleteEventFlag(g_scmd_evid);
-	DeleteEventFlag(g_sfile_evid);
+	DeleteEventFlag(g_fio_fsv_evfid);
+	DeleteEventFlag(g_cdvdman_intr_evfid);
+	DeleteEventFlag(g_ncmd_evfid);
+	DeleteEventFlag(g_scmd_evfid);
+	DeleteEventFlag(g_sfile_evfid);
+#ifdef CDVD_VARIANT_XOSD
+	DeleteEventFlag(g_cdvdman_csys_evfid);
+#endif
 	return 0;
 }
 
-static int cdvdman_devready()
+static int cdvdman_devready(void)
 {
 	int i;
-	USE_DEV5_MMIO_HWPORT();
 
 	for ( i = 0; i < 100; i += 1 )
 	{
-		if ( (dev5_mmio_hwport->m_dev5_reg_00A & 1) )
+		// The following direct register access was replaced with call for ioprp300x
+		if ( (sceCdStatus() & SCECdStatShellOpen) )
 		{
 			g_cdvdman_iocache = 0;
 			return -EIO;
 		}
-		if ( (dev5_mmio_hwport->m_dev5_reg_005 & 0xC0) == 0x40 && !g_cdvdman_istruct.m_read2_flag && !g_cdvdman_ee_rpc_fno )
+		// The following direct register access was replaced with call for ioprp300x
+		if ( (sceCdDiskReady(8) & 0xC0) == 0x40 && !g_cdvdman_istruct.m_read2_flag && !g_cdvdman_ee_rpc_fno )
 		{
 			return 1;
 		}
@@ -495,6 +609,7 @@ static void cdvdman_iormode(sceCdRMode *rmode, int fmode, int layer)
 			rmode->spindlctrl = SCECdSpinStm;
 			return;
 		}
+		rmode->spindlctrl = (u8)g_cdvdman_spinnom;
 	}
 	else if ( g_cdvdman_spinnom == -1 )
 	{
@@ -525,9 +640,7 @@ static void cdvdman_iormode(sceCdRMode *rmode, int fmode, int layer)
 				rmode->spindlctrl = SCECdSpinNom;
 				break;
 		}
-		return;
 	}
-	rmode->spindlctrl = (u8)g_cdvdman_spinnom;
 }
 
 static int cdrom_dopen(iop_file_t *f, const char *dirname)
@@ -540,21 +653,21 @@ static int cdrom_dopen(iop_file_t *f, const char *dirname)
 	u32 efbits;
 
 	VERBOSE_PRINTF(1, "fileIO DOPEN name= %s layer %d\n", dirname, f->unit);
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
 	for ( i = 0; (i < (sizeof(g_cdvdman_fhinfo) / sizeof(g_cdvdman_fhinfo[0]))) && g_cdvdman_fhinfo[i].m_fd_flags;
 				i += 1 )
 	{
 	}
 	if ( i == (sizeof(g_cdvdman_fhinfo) / sizeof(g_cdvdman_fhinfo[0])) )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -EMFILE;
 	}
 	f->privdata = (void *)i;
 	is_devready = cdvdman_devready();
 	if ( is_devready < 0 )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return is_devready;
 	}
 	strncpy(path_name, dirname, sizeof(path_name));
@@ -571,7 +684,7 @@ static int cdrom_dopen(iop_file_t *f, const char *dirname)
 	if ( (unsigned int)(f->unit) >= 2 )
 	{
 		PRINTF("open fail name %s\n", path_name);
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -ENOENT;
 	}
 	g_cdvdman_fhinfo[i].m_file_lsn = 0;
@@ -580,7 +693,7 @@ static int cdrom_dopen(iop_file_t *f, const char *dirname)
 	if ( file_lsn_tmp < 0 )
 	{
 		PRINTF("open fail directory %s\n", path_name);
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -ENOENT;
 	}
 	g_cdvdman_fhinfo[i].m_file_lsn = file_lsn_tmp;
@@ -588,7 +701,7 @@ static int cdrom_dopen(iop_file_t *f, const char *dirname)
 	g_cdvdman_fhinfo[i].m_filemode = 0;
 	g_cdvdman_fhinfo[i].m_fd_flags = 1;
 	g_cdvdman_fhinfo[i].m_fd_layer = f->unit;
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return 0;
 }
 
@@ -638,11 +751,11 @@ static int cdrom_getstat(iop_file_t *f, const char *name, iox_stat_t *buf)
 	u32 efbits;
 
 	VERBOSE_PRINTF(1, "fileIO GETSTAT name= %s layer= %d\n", name, f->unit);
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
 	devready_tmp = cdvdman_devready();
 	if ( devready_tmp < 0 )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return devready_tmp;
 	}
 	strncpy(filename, name, sizeof(filename));
@@ -666,14 +779,15 @@ static int cdrom_getstat(iop_file_t *f, const char *name, iox_stat_t *buf)
 		&& !(cdvdman_cdfname(filename) && sceCdLayerSearchFile(&fp.m_file_struct, filename, f->unit)) )
 	{
 		PRINTF("open fail name %s\n", name);
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -ENOENT;
 	}
 	cdvdman_fillstat(filename, buf, &fp);
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return 1;
 }
 
+// cppcheck-suppress constParameterCallback
 static int cdrom_dread(iop_file_t *f, iox_dirent_t *buf)
 {
 	int devready_tmp;
@@ -683,11 +797,11 @@ static int cdrom_dread(iop_file_t *f, iox_dirent_t *buf)
 
 	memset(&fp, 0, sizeof(fp));
 	VERBOSE_PRINTF(1, "fileIO DREAD\n");
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
 	devready_tmp = cdvdman_devready();
 	if ( devready_tmp < 0 )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return devready_tmp;
 	}
 	fh = &g_cdvdman_fhinfo[(int)f->privdata];
@@ -695,7 +809,7 @@ static int cdrom_dread(iop_file_t *f, iox_dirent_t *buf)
 	devready_tmp = sceCdReadDir(&fp.m_file_struct, fh->m_file_lsn, fh->m_read_pos, fh->m_fd_layer);
 	if ( devready_tmp < 0 )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -ENOENT;
 	}
 	if ( devready_tmp )
@@ -705,7 +819,7 @@ static int cdrom_dread(iop_file_t *f, iox_dirent_t *buf)
 	}
 	strncpy(buf->name, fp.m_file_struct.name, sizeof(buf->name));
 	cdvdman_fillstat(fp.m_file_struct.name, &buf->stat, &fp);
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return devready_tmp;
 }
 
@@ -774,14 +888,16 @@ static int cdvd_odcinit(cdvdman_fhinfo_t *fh, int open_or_close, int id)
 		}
 		if ( cache_result >= 0 )
 		{
-			for ( i = 0; i <= 0x7FFF; i += 1 )
+			if ( !g_cdvdman_cache_sector_count )
+				__builtin_trap();
+			for ( i = 0; (int)i < (int)(g_cdvdman_cache_sector_count << 11); i += 1 )
 			{
 				((char *)g_cdvdman_temp_buffer_ptr)[i] = 0;
 			}
-			for ( i = 0; (int)i < (int)(ioctl_arg >> 15); i += 1 )
+			for ( i = 0; (int)i < (int)((ioctl_arg >> 11) / g_cdvdman_cache_sector_count); i += 1 )
 			{
-				cache_result = write(cache_file_fd_new, g_cdvdman_temp_buffer_ptr, 0x8000);
-				if ( cache_result != 0x8000 )
+				cache_result = write(cache_file_fd_new, g_cdvdman_temp_buffer_ptr, g_cdvdman_cache_sector_count << 11);
+				if ( cache_result != (g_cdvdman_cache_sector_count << 11) )
 				{
 					if ( cache_result >= 0 )
 					{
@@ -793,7 +909,9 @@ static int cdvd_odcinit(cdvdman_fhinfo_t *fh, int open_or_close, int id)
 		}
 		if ( cache_result >= 0 )
 		{
-			for ( i = 0; (int)i < (int)((ioctl_arg >> 11) - 0x10 * (ioctl_arg >> 15)); i += 1 )
+			for ( i = 0; (int)i < (int)((ioctl_arg >> 11)
+																	- g_cdvdman_cache_sector_count * ((ioctl_arg >> 11) / g_cdvdman_cache_sector_count));
+						i += 1 )
 			{
 				cache_result = write(cache_file_fd_new, fh->m_fd_rcvbuf, 0x800);
 				if ( cache_result != 0x800 )
@@ -888,7 +1006,7 @@ static int cdvdman_cache_invalidate(cdvdman_fhinfo_t *fh, int index)
 	return fileio_res;
 }
 
-static int cdvdman_invcaches()
+static int cdvdman_invcaches(void)
 {
 	unsigned int i;
 
@@ -911,7 +1029,7 @@ static int cdrom_internal_cache_read(const iop_file_t *f, int nbytes)
 	int cluster_cur;
 	unsigned int i;
 
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	if ( cdvdman_devready() < 0 )
 	{
 		g_cdvdman_iocache = 0;
@@ -995,7 +1113,7 @@ static int cdrom_internal_write_cache(const iop_file_t *f, unsigned int nbytes)
 	int write_ret;
 	unsigned int i;
 	int tray_open;
-	int Error;
+	int last_err;
 	sceCdRMode rmode;
 
 	g_cdvdman_iocache = 0;
@@ -1003,7 +1121,7 @@ static int cdrom_internal_write_cache(const iop_file_t *f, unsigned int nbytes)
 	{
 		return -EBUSY;
 	}
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	if ( nbytes > fh->m_file_size - fh->m_read_pos )
 	{
 		nbytes = fh->m_file_size - fh->m_read_pos;
@@ -1031,7 +1149,7 @@ static int cdrom_internal_write_cache(const iop_file_t *f, unsigned int nbytes)
 		if ( !(((int)fh->m_fd_rcvbuf[(i - cluster_cur) >> 3] >> ((i - cluster_cur) & 7)) & 1) )
 		{
 			tray_open = 0;
-			while ( !sceCdRE(fh->m_file_lsn + 8 * i, 8u, g_cdvdman_temp_buffer_ptr, &rmode) )
+			while ( !sceCdRE(fh->m_file_lsn + 8 * i, 8, g_cdvdman_temp_buffer_ptr, &rmode) )
 			{
 				if ( (sceCdStatus() & SCECdStatShellOpen) )
 				{
@@ -1042,10 +1160,11 @@ static int cdrom_internal_write_cache(const iop_file_t *f, unsigned int nbytes)
 				DelayThread(10000);
 			}
 			sceCdSync(0);
-			Error = sceCdGetError();
-			if ( Error || tray_open )
+			last_err = sceCdGetError();
+			if ( last_err != SCECdErNO || tray_open )
 			{
-				VERBOSE_KPRINTF(0, "Read Error= 0x%02x\n", Error);
+				// The following Kprintf was modified for ioprp300x
+				VERBOSE_KPRINTF(0, "Read Error= 0x%02x Tray open %d\n", last_err, tray_open);
 				return -ECOMM;
 			}
 			lseek_result = lseek(fh->m_cache_file_fd, (i * 0x4000) + fh->m_sector_count_total, 0);
@@ -1079,7 +1198,7 @@ static int cdvdfile_cache_read(const iop_file_t *f, void *buf, int nbyte)
 	{
 		return -EINVAL;
 	}
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	nbyte_tmp =
 		((unsigned int)nbyte > fh->m_file_size - fh->m_read_pos) ? fh->m_file_size - fh->m_read_pos : (unsigned int)nbyte;
 	VERBOSE_KPRINTF(1, "_cdvdfile_cache_read %d<->%d\n", fh->m_read_pos, fh->m_read_pos + nbyte_tmp);
@@ -1132,7 +1251,7 @@ static int cdrom_open(iop_file_t *f, const char *name, int mode, int arg4)
 	devready_tmp = 0;
 	fds1 = 0;
 	VERBOSE_PRINTF(1, "fileIO OPEN name= %s mode= 0x%08x layer %d\n", name, mode, f->unit);
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
 	emptyfdfound = 0;
 	streamfdfound = 0;
 	for ( i = 0; i < (sizeof(g_cdvdman_fhinfo) / sizeof(g_cdvdman_fhinfo[0])); i += 1 )
@@ -1150,11 +1269,11 @@ static int cdrom_open(iop_file_t *f, const char *name, int mode, int arg4)
 	if ( !emptyfdfound || streamfdfound )
 	{
 		PRINTF("open fail name %s\n", name);
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -EMFILE;
 	}
 	f->privdata = (void *)fds1;
-	fh = &g_cdvdman_fhinfo[fds1];
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	strncpy(filename, name, sizeof(filename));
 	cdvdman_cdfname(filename);
 	g_cdvdman_srchspd = (!(mode & 0x40000000) && !cdvdman_l0check(f->unit)) ?
@@ -1194,12 +1313,19 @@ static int cdrom_open(iop_file_t *f, const char *name, int mode, int arg4)
 				}
 			}
 		}
+#ifdef CDVD_VARIANT_OSD
+		else if ( !strcmp(filename, "sce_dev5;1") )
+		{
+			fp.lsn = -1;
+			fp.size = 0;
+		}
+#endif
 		else
 		{
 			devready_tmp = cdvdman_devready();
 			if ( devready_tmp < 0 )
 			{
-				SetEventFlag(g_fio_fsv_evid, 1);
+				SetEventFlag(g_fio_fsv_evfid, 1);
 				return devready_tmp;
 			}
 			if ( !sceCdLayerSearchFile(&fp, filename, f->unit) )
@@ -1211,7 +1337,7 @@ static int cdrom_open(iop_file_t *f, const char *name, int mode, int arg4)
 	if ( devready_tmp < 0 )
 	{
 		PRINTF("open fail name %s\n", filename);
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return devready_tmp;
 	}
 	fh->m_fd_flags = 1;
@@ -1227,7 +1353,7 @@ static int cdrom_open(iop_file_t *f, const char *name, int mode, int arg4)
 		if ( !sceCdStStart(fp.lsn, &rmode) )
 		{
 			fh->m_fd_flags = 0;
-			SetEventFlag(g_fio_fsv_evid, 1);
+			SetEventFlag(g_fio_fsv_evfid, 1);
 			return -ENOENT;
 		}
 		g_cdvdman_strmerr = 0;
@@ -1258,11 +1384,13 @@ static int cdrom_open(iop_file_t *f, const char *name, int mode, int arg4)
 		fh->m_read_pos = 0;
 		fh->m_file_size = 0;
 		fh->m_file_lsn = 0;
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return devready_tmp;
 	}
 	f->mode = O_RDONLY;
-	SetEventFlag(g_fio_fsv_evid, 1);
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "open end file_lbn= %d size= %d fds= %d\n", fh->m_file_lsn, fh->m_file_size, fds1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return 0;
 }
 
@@ -1272,21 +1400,21 @@ static int cdrom_close(iop_file_t *f)
 	u32 efbits;
 
 	VERBOSE_PRINTF(1, "fileIO CLOSE\n");
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	if ( (fh->m_fd_flags & 8) )
 	{
 		g_cdvdman_strmerr = 0;
 		// The following call to sceCdStStop was inlined
 		if ( !sceCdStStop() )
 		{
-			SetEventFlag(g_fio_fsv_evid, 1);
+			SetEventFlag(g_fio_fsv_evfid, 1);
 			return -EIO;
 		}
 	}
 	if ( ((fh->m_fd_flags & 0xC) == 4 && cdvd_odcinit(fh, 0, (int)f->privdata) < 0) )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 		return -EIO;
 	}
 	fh->m_file_lsn = 0;
@@ -1296,7 +1424,7 @@ static int cdrom_close(iop_file_t *f)
 	fh->m_fd_layer = 0;
 	fh->m_filemode = 1;
 	f->mode = 0;
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return 0;
 }
 
@@ -1307,9 +1435,8 @@ static int cdrom_internal_read(const iop_file_t *f, char *addr, int nbytes)
 	int nbytes_segment;
 	int nbytes_div_2048;
 	unsigned int sec;
-	int read_error;
 	unsigned int sectors_count;
-	int Error;
+	int last_err;
 	sceCdRMode rmode;
 	int i;
 	unsigned int filesize_bsr_11;
@@ -1437,10 +1564,10 @@ static int cdrom_internal_read(const iop_file_t *f, char *addr, int nbytes)
 					DelayThread(10000);
 				}
 				sceCdSync(0);
-				Error = sceCdGetError();
-				if ( Error )
+				last_err = sceCdGetError();
+				if ( last_err != SCECdErNO )
 				{
-					PRINTF("Read Error= 0x%02x\n", Error);
+					PRINTF("Read Error= 0x%02x\n", last_err);
 					g_cdvdman_iocache = 0;
 					break;
 				}
@@ -1457,10 +1584,10 @@ static int cdrom_internal_read(const iop_file_t *f, char *addr, int nbytes)
 				DelayThread(10000);
 			}
 			sceCdSync(0);
-			Error = sceCdGetError();
-			if ( Error )
+			last_err = sceCdGetError();
+			if ( last_err != SCECdErNO )
 			{
-				PRINTF("Read Error= 0x%02x\n", Error);
+				PRINTF("Read Error= 0x%02x\n", last_err);
 				g_cdvdman_iocache = 0;
 				break;
 			}
@@ -1488,11 +1615,11 @@ static int cdrom_internal_read(const iop_file_t *f, char *addr, int nbytes)
 				DelayThread(10000);
 			}
 			sceCdSync(0);
-			read_error = sceCdGetError();
+			last_err = sceCdGetError();
 			g_cdvdman_iocache = 0;
-			if ( read_error )
+			if ( last_err != SCECdErNO )
 			{
-				PRINTF("Read Error= 0x%02x\n", read_error);
+				PRINTF("Read Error= 0x%02x\n", last_err);
 				break;
 			}
 		}
@@ -1514,7 +1641,7 @@ static int cdrom_stream_read(const iop_file_t *f, char *bbuf, int nbytes)
 	sceCdRMode rmode;
 	int buf;
 
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	g_cdvdman_strmerr = 0;
 	cdvdman_iormode(&rmode, fh->m_filemode, f->unit);
 	rmode.spindlctrl = SCECdSpinStm;
@@ -1525,6 +1652,7 @@ static int cdrom_stream_read(const iop_file_t *f, char *bbuf, int nbytes)
 	return buf << 11;
 }
 
+// cppcheck-suppress constParameterCallback
 static int cdrom_read(iop_file_t *f, void *buf, int nbytes)
 {
 	cdvdman_fhinfo_t *fh;
@@ -1535,8 +1663,8 @@ static int cdrom_read(iop_file_t *f, void *buf, int nbytes)
 	{
 		return -EINVAL;
 	}
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	if ( cdvdman_mediactl(2) )
 	{
 		g_cdvdman_iocache = 0;
@@ -1588,25 +1716,59 @@ static int cdrom_read(iop_file_t *f, void *buf, int nbytes)
 			}
 		}
 	}
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return rc;
 }
 
 static int cdrom_ioctl(iop_file_t *f, int arg, void *param)
 {
+#ifdef CDVD_VARIANT_OSD
+	USE_IOP_MMIO_HWPORT();
+#endif
+
 	(void)f;
 
 	switch ( arg )
 	{
+#ifdef CDVD_VARIANT_OSD
+		case 0x6310:
+			return mfc0(PRID);
+		case 0x6311:
+			if ( mfc0(PRID) < 35 )
+			{
+				return -22;
+			}
+			if ( *(u32 *)param )
+			{
+				/* 0xBF808284 */ *(u32 *)&iop_mmio_hwport->sio2.unused[0] |= 1;
+			}
+			else
+			{
+				/* 0xBF808284 */ *(u32 *)&iop_mmio_hwport->sio2.unused[0] &= ~1;
+			}
+			return 0;
+		case 0x6312:
+			return mfc0(PRID) >= 35 ? (int)(/* 0xBF808284 */ *(u32 *)&iop_mmio_hwport->sio2.unused[0] & 1) : -22;
+#endif
 		case 0x10000:
 			g_cdvdman_spinnom = -1;
 			sceCdSpinCtrlIOP((u32)param);
 			return 0;
+#ifdef CDVD_VARIANT_OSD
+		case 0x10008:
+			sceCdDecSet(*(u32 *)param, *((u32 *)param + 1), *((u32 *)param + 2));
+			return 0;
+		case 0x10020:
+			return sceCdReadKey(*(u32 *)param, *((u32 *)param + 1), *((u32 *)param + 2), (u8 *)param + 12) ? 1 : -16;
+		case 0x10030:
+			return sceCdGetDiskType();
+#endif
 		default:
 			return -EIO;
 	}
 }
 
+// cppcheck-suppress constParameterCallback
 static int cdrom_ioctl2(iop_file_t *f, int request, void *argp, size_t arglen, void *bufp, size_t buflen)
 {
 	const cdvdman_fhinfo_t *fh;
@@ -1618,8 +1780,8 @@ static int cdrom_ioctl2(iop_file_t *f, int request, void *argp, size_t arglen, v
 	(void)bufp;
 	(void)buflen;
 
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	retval = -EIO;
 	if ( (fh->m_fd_flags & 8) )
 	{
@@ -1648,7 +1810,7 @@ static int cdrom_ioctl2(iop_file_t *f, int request, void *argp, size_t arglen, v
 				break;
 		}
 	}
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return retval;
 }
 
@@ -1670,14 +1832,14 @@ cdrom_devctl(iop_file_t *f, const char *name, int cmd, void *argp, unsigned int
 	retval2 = 0;
 	if ( cmd != CDIOC_BREAK )
 	{
-		WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
+		WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
 	}
 	switch ( cmd )
 	{
 		case CDIOC_READCLOCK:
 			for ( i = 0; i < 3 && !retval2; i += 1 )
 			{
-				WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 				retval2 = sceCdReadClock((sceCdCLOCK *)bufp);
 			}
 			retval2 = (retval2 != 1) ? -EIO : 0;
@@ -1686,7 +1848,7 @@ cdrom_devctl(iop_file_t *f, const char *name, int cmd, void *argp, unsigned int
 		case 0x431D:
 			for ( i = 0; i < 3 && !retval2; i += 1 )
 			{
-				WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 				retval2 = sceCdReadGUID((u64 *)bufp);
 			}
 			retval2 = (retval2 != 1) ? -EIO : 0;
@@ -1710,7 +1872,7 @@ cdrom_devctl(iop_file_t *f, const char *name, int cmd, void *argp, unsigned int
 		case CDIOC_POWEROFF:
 			for ( i = 0; i < 3 && !retval2; i += 1 )
 			{
-				WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 				retval2 = sceCdPowerOff((u32 *)bufp);
 			}
 			retval2 = (retval2 != 1) ? -EIO : 0;
@@ -1725,7 +1887,7 @@ cdrom_devctl(iop_file_t *f, const char *name, int cmd, void *argp, unsigned int
 		case 0x4326:
 			for ( i = 0; i < 3 && !retval2; i += 1 )
 			{
-				WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 				retval2 = sceCdReadModelID((unsigned int *)bufp);
 			}
 			retval2 = (retval2 != 1) ? -EIO : 0;
@@ -1739,6 +1901,12 @@ cdrom_devctl(iop_file_t *f, const char *name, int cmd, void *argp, unsigned int
 			retval2 = (!sceCdBreak()) ? -EIO : 0;
 			sceCdSync(4);
 			break;
+#ifdef CDVD_VARIANT_XOSD
+		case 0x437F:
+			sc_tmp_3 = *(u32 *)argp;
+			retval2 = (sc_tmp_3 - 4 >= 0x15) ? -22 : sceCdSC(0xFFFFFFDD, (int *)&sc_tmp_3);
+			break;
+#endif
 		case CDIOC_SPINNOM:
 			g_cdvdman_spinnom = SCECdSpinNom;
 			break;
@@ -1851,11 +2019,12 @@ cdrom_devctl(iop_file_t *f, const char *name, int cmd, void *argp, unsigned int
 	}
 	if ( cmd != CDIOC_BREAK )
 	{
-		SetEventFlag(g_fio_fsv_evid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
 	}
 	return retval2;
 }
 
+// cppcheck-suppress constParameterCallback
 static int cdrom_lseek(iop_file_t *f, int offset, int pos)
 {
 	int retval;
@@ -1864,8 +2033,8 @@ static int cdrom_lseek(iop_file_t *f, int offset, int pos)
 
 	retval = -EPERM;
 	VERBOSE_PRINTF(1, "fileIO SEEK\n");
-	WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
-	fh = &g_cdvdman_fhinfo[(int)f->privdata];
+	WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	fh = &g_cdvdman_fhinfo[(uiptr)f->privdata];
 	switch ( pos )
 	{
 		case 0:
@@ -1893,7 +2062,7 @@ static int cdrom_lseek(iop_file_t *f, int offset, int pos)
 			retval = -EIO;
 		}
 	}
-	SetEventFlag(g_fio_fsv_evid, 1);
+	SetEventFlag(g_fio_fsv_evfid, 1);
 	return retval;
 }
 
@@ -1934,7 +2103,7 @@ int sceCdSync(int mode)
 		case 0:
 			while ( !sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 			}
 			break;
 		case 1:
@@ -1945,7 +2114,7 @@ int sceCdSync(int mode)
 			vSetAlarm(&sysclk, (unsigned int (*)(void *))sync_timeout_alarm_cb, &sysclk);
 			while ( !sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 			}
 			vCancelAlarm((unsigned int (*)(void *))sync_timeout_alarm_cb, &sysclk);
 			break;
@@ -1955,14 +2124,14 @@ int sceCdSync(int mode)
 			vSetAlarm(&sysclk, (unsigned int (*)(void *))sync_timeout_alarm_cb, &sysclk);
 			while ( !sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 			}
 			vCancelAlarm((unsigned int (*)(void *))sync_timeout_alarm_cb, &sysclk);
 			break;
 		case 5:
 			while ( !sceCdCheckCmd() )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 			}
 			break;
 		case 6:
@@ -1971,7 +2140,7 @@ int sceCdSync(int mode)
 			vSetAlarm(&sysclk, (unsigned int (*)(void *))sync_timeout_alarm_cb, &sysclk);
 			while ( !sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 			}
 			vCancelAlarm((unsigned int (*)(void *))sync_timeout_alarm_cb, &sysclk);
 			break;
@@ -1979,7 +2148,7 @@ int sceCdSync(int mode)
 			while ( !sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag || g_cdvdman_ee_rpc_fno
 							|| g_cdvdman_istruct.m_stream_flag )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 				if ( g_cdvdman_ee_rpc_fno )
 				{
 					DelayThread(8000);
@@ -1991,24 +2160,24 @@ int sceCdSync(int mode)
 				!sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag || g_cdvdman_ee_rpc_fno
 				|| (g_cdvdman_istruct.m_stream_flag));
 		case 32:
-			WaitEventFlag(g_cdvdman_intr_efid, 0x21, WEF_OR, &efbits);
-			ReferEventFlagStatus(g_cdvdman_intr_efid, &efinfo);
+			WaitEventFlag(g_cdvdman_intr_evfid, 0x21, WEF_OR, &efbits);
+			ReferEventFlagStatus(g_cdvdman_intr_evfid, &efinfo);
 			if ( !(efinfo.currBits & 0x20) )
 			{
-				if ( g_cdvdman_istruct.m_last_error )
+				if ( g_cdvdman_istruct.m_last_error != SCECdErNO )
 				{
-					SetEventFlag(g_cdvdman_intr_efid, 0x20);
+					SetEventFlag(g_cdvdman_intr_evfid, 0x20);
 				}
 				else
 				{
-					WaitEventFlag(g_cdvdman_intr_efid, 0x20, WEF_AND, &efbits);
+					WaitEventFlag(g_cdvdman_intr_evfid, 0x20, WEF_AND, &efbits);
 				}
 			}
 			break;
 		default:
 			while ( !sceCdCheckCmd() || g_cdvdman_istruct.m_read2_flag )
 			{
-				WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+				WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
 			}
 			break;
 	}
@@ -2033,7 +2202,7 @@ int sceCdLayerSearchFile(sceCdlFILE *fp, const char *path, int layer)
 	int search_res;
 	u32 efbits;
 
-	if ( PollEventFlag(g_sfile_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( PollEventFlag(g_sfile_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
@@ -2044,7 +2213,7 @@ int sceCdLayerSearchFile(sceCdlFILE *fp, const char *path, int layer)
 	g_cdvdman_sfname[i] = 0;
 	g_cdvdman_srchspd = 1;
 	search_res = CdSearchFileInner((cdvdman_filetbl_entry_t *)fp, g_cdvdman_sfname, layer);
-	vSetEventFlag(g_sfile_evid, 1);
+	vSetEventFlag(g_sfile_evfid, 1);
 	return search_res;
 }
 
@@ -2064,35 +2233,59 @@ int sceCdDiskReady(int mode)
 	USE_DEV5_MMIO_HWPORT();
 
 	efbits = 0;
-	VERBOSE_KPRINTF(1, "DISK READY call from iop\n");
+	// The following Kprintf was modified for ioprp300x
+	VERBOSE_KPRINTF(1, "DISK READY call from iop %d\n", mode);
+#ifdef CDVD_VARIANT_XOSD
+	if ( g_cdvdman_istruct.m_cd_mode_ps2_atapi == 1 )
+	{
+		return mode == 8 ? -1 : 6;
+	}
+	switch ( get_disk_type_ex() )
+	{
+		case SCECdNODISC:
+		case 257:
+			return 2;
+		default:
+			break;
+	}
+#endif
 	switch ( mode )
 	{
 		case 0:
 			VERBOSE_KPRINTF(1, "Wait Drive Ready %x\n", dev5_mmio_hwport->m_dev5_reg_005);
-			while ( 1 )
+			while ( g_cdvdman_istruct.m_read2_flag )
 			{
-				if ( !g_cdvdman_istruct.m_read2_flag )
-				{
-					return 2;
-				}
 				// The following call to sceCdGetDiskType was inlined
+#ifdef CDVD_VARIANT_XOSD
+				switch ( get_disk_type_ex() )
+#else
 				switch ( sceCdGetDiskType() )
+#endif
 				{
 					case SCECdDETCT:
 					case SCECdDETCTCD:
 					case SCECdDETCTDVDS:
 					case SCECdDETCTDVDD:
-						break;
+						while ( (dev5_mmio_hwport->m_dev5_reg_005 & 0xC0) != 0x40 )
+						{
+							vDelayThread(2000);
+							WaitEventFlag(g_cdvdman_intr_evfid, 1, WEF_AND, &efbits);
+#ifdef CDVD_VARIANT_XOSD
+							if ( !get_disk_type_ex() )
+							{
+								return 2;
+							}
+#endif
+						}
+						continue;
 					default:
-						return 2;
-				}
-				while ( (dev5_mmio_hwport->m_dev5_reg_005 & 0xC0) != 0x40 )
-				{
-					vDelayThread(2000);
-					WaitEventFlag(g_cdvdman_intr_efid, 1, WEF_AND, &efbits);
+						break;
 				}
+				break;
 			}
-			break;
+			// The following Kprintf was added for ioprp300x
+			VERBOSE_KPRINTF(1, "Wait Exit\n");
+			return 2;
 		case 8:
 			return (u8)dev5_mmio_hwport->m_dev5_reg_005;
 		case 1:
@@ -2108,24 +2301,80 @@ int sceCdDiskReady(int mode)
 
 int sceCdGetDiskType(void)
 {
+#ifdef CDVD_VARIANT_XOSD
+	int cdvd_register;
+
+	VERBOSE_KPRINTF(1, "sceCdGetDiskType Call\n");
+	cdvd_register = get_cdvd_register(0x0F);
+	VERBOSE_KPRINTF(1, "sceCdGetDiskType 0x%02x\n", cdvd_register);
+	return cdvd_register;
+#else
 	USE_DEV5_MMIO_HWPORT();
 
 	return (u8)dev5_mmio_hwport->m_dev5_reg_00F;
+#endif
+}
+
+#ifdef CDVD_VARIANT_XOSD
+static int get_disk_type_ex(void)
+{
+	int IntrContext;
+	int retval;
+	int state;
+	USE_DEV5_MMIO_HWPORT();
+
+	IntrContext = QueryIntrContext();
+	if ( IntrContext )
+	{
+		CpuSuspendIntr(&state);
+	}
+	retval = (g_cdvdman_istruct.m_cd_mode_ps2_atapi == 1) ? 257 : dev5_mmio_hwport->m_dev5_reg_00F;
+	if ( IntrContext )
+	{
+		CpuResumeIntr(state);
+	}
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+int sceCdGetWakeUpReason(void)
+{
+	int wakeup_reason_reg;
+
+	VERBOSE_KPRINTF(1, "sceCdGetWakeUpReason Call\n");
+	wakeup_reason_reg = get_cdvd_register(0x15);
+	if ( wakeup_reason_reg != -1 )
+	{
+		wakeup_reason_reg &= 0xF;
+	}
+	VERBOSE_KPRINTF(1, "sceCdGetWakeUpReason 0x%02x\n", wakeup_reason_reg);
+	return wakeup_reason_reg;
 }
+#endif
 
 int sceCdStatus(void)
 {
 	int reg_00A_tmp;
+#ifndef CDVD_VARIANT_XOSD
 	u32 status_tmp;
+#endif
+#ifndef CDVD_VARIANT_XOSD
 	USE_DEV5_MMIO_HWPORT();
+#endif
 
+#ifdef CDVD_VARIANT_XOSD
+	reg_00A_tmp = get_cdvd_register(0x0A);
+#else
 	reg_00A_tmp = dev5_mmio_hwport->m_dev5_reg_00A;
+#endif
+#ifndef CDVD_VARIANT_XOSD
 	// The following call to sceCdGetDiskType was inlined
 	if ( sceCdGetDiskType() == SCECdNODISC )
 	{
 		u8 rdata_tmp;
 
-		if ( !g_cdvdman_istruct.m_tray_is_open && cdvdman_scmd_sender_03_48(&rdata_tmp, &status_tmp) == 1 && !status_tmp )
+		if ( !g_cdvdman_istruct.m_tray_is_open && cdvdman_scmd_sender_03_30(&rdata_tmp, &status_tmp) == 1 && !status_tmp )
 		{
 			reg_00A_tmp &= ~SCECdStatShellOpen;
 			if ( (rdata_tmp & 8) )
@@ -2138,6 +2387,7 @@ int sceCdStatus(void)
 			reg_00A_tmp = SCECdStatStop;
 		}
 	}
+#endif
 	if ( g_cdvdman_istruct.m_use_toc )
 	{
 		reg_00A_tmp &= ~SCECdStatShellOpen;
@@ -2149,6 +2399,15 @@ int sceCdStatus(void)
 	return reg_00A_tmp;
 }
 
+#ifdef CDVD_VARIANT_OSD
+int sceCdStatus2(void)
+{
+	USE_DEV5_MMIO_HWPORT();
+
+	return !g_cdvdman_istruct.m_power_flag ? (u8)dev5_mmio_hwport->m_dev5_reg_00A : -1;
+}
+#endif
+
 sceCdlLOCCD *sceCdIntToPos(u32 i, sceCdlLOCCD *p)
 {
 	p->sector = 16 * ((i + 150) % 75 / 10) + (i + 150) % 75 % 10;
@@ -2157,6 +2416,7 @@ sceCdlLOCCD *sceCdIntToPos(u32 i, sceCdlLOCCD *p)
 	return p;
 }
 
+// cppcheck-suppress constParameterPointer
 u32 sceCdPosToInt(sceCdlLOCCD *p)
 {
 	return 75 * (60 * (10 * (p->minute >> 4) + (p->minute & 0xF)) + 10 * (p->second >> 4) + (p->second & 0xF))
@@ -2208,7 +2468,7 @@ static int read_id_from_rom(int mode, int *buf)
 	return 1;
 }
 
-static int query_boot_mode_6_nonzero()
+static int query_boot_mode_6_nonzero(void)
 {
 	int *BootMode;
 
@@ -2216,7 +2476,7 @@ static int query_boot_mode_6_nonzero()
 	return !(!BootMode || (*(u16 *)BootMode & 0xFFFC) != 0x60);
 }
 
-static int query_boot_mode_6_zero()
+static int query_boot_mode_6_zero(void)
 {
 	return !QueryBootMode(6);
 }
@@ -2287,6 +2547,8 @@ int sceCdStInit(u32 bufmax, u32 bankmax, void *buffer)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStInit call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 5;
 	devctl_req.m_posszarg1 = bufmax;
@@ -2295,11 +2557,14 @@ int sceCdStInit(u32 bufmax, u32 bankmax, void *buffer)
 	return (devctl("cdrom_stm0:", 0x4393, &devctl_req, sizeof(devctl_req), &buf, 4) >= 0) ? buf : 0;
 }
 
+// cppcheck-suppress constParameterPointer
 int sceCdStStart(u32 lbn, sceCdRMode *mode)
 {
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStStart call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_rmode.datapattern = mode->datapattern;
 	devctl_req.m_rmode.spindlctrl = mode->spindlctrl;
@@ -2314,6 +2579,8 @@ int sceCdStSeekF(unsigned int lsn)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStSeekF call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 9;
 	devctl_req.m_posszarg1 = lsn;
@@ -2325,6 +2592,8 @@ int sceCdStSeek(u32 lbn)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStSeek call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_posszarg1 = lbn;
 	devctl_req.m_cmdid = 4;
@@ -2336,6 +2605,8 @@ int sceCdStStop(void)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStStop call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 3;
 	return (devctl("cdrom_stm0:", 0x4393, &devctl_req, sizeof(devctl_req), &buf, 4) >= 0) ? buf : 0;
@@ -2348,6 +2619,8 @@ int sceCdStRead(u32 sectors, u32 *buffer, u32 mode, u32 *error)
 
 	(void)mode;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStRead call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 1;
 	devctl_req.m_posszarg2 = sectors;
@@ -2365,6 +2638,8 @@ int sceCdStPause(void)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStPause call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 7;
 	return (devctl("cdrom_stm0:", 0x4393, &devctl_req, sizeof(devctl_req), &buf, 4) >= 0) ? buf : 0;
@@ -2375,6 +2650,8 @@ int sceCdStResume(void)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStResume call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 8;
 	return (devctl("cdrom_stm0:", 0x4393, &devctl_req, sizeof(devctl_req), &buf, 4) >= 0) ? buf : 0;
@@ -2385,6 +2662,8 @@ int sceCdStStat(void)
 	cdrom_stm_devctl_t devctl_req;
 	int buf;
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdStStat call IOP\n");
 	memset(&devctl_req, 0, sizeof(devctl_req));
 	devctl_req.m_cmdid = 6;
 	return (devctl("cdrom_stm0:", 0x4393, &devctl_req, sizeof(devctl_req), &buf, 4) >= 0) ? buf : 0;
@@ -2522,7 +2801,11 @@ static int CD_newmedia(int arg)
 	int ptsector;
 
 	ptsector = 0;
+#ifdef CDVD_VARIANT_XOSD
+	DiskType = get_disk_type_ex();
+#else
 	DiskType = sceCdGetDiskType();
+#endif
 	switch ( DiskType )
 	{
 		case SCECdPSCD:
@@ -2793,7 +3076,7 @@ static int disc_read(int size, int loc, void *buffer, int layer)
 			sceCdSync(3);
 		}
 	}
-	if ( !has_success && !sceCdGetError() )
+	if ( !has_success && sceCdGetError() != SCECdErNO )
 	{
 		int cache_path_sz;
 
@@ -2870,7 +3153,7 @@ static int disc_read(int size, int loc, void *buffer, int layer)
 			return 0;
 		}
 		sceCdSync(3);
-		if ( !sceCdGetError() )
+		if ( sceCdGetError() != SCECdErNO )
 		{
 			return size;
 		}
@@ -2910,7 +3193,7 @@ static int path_tbl_init(u32 blocks, char *fname, int action)
 			if ( !strncmp(cachedir, "pfs", 3) )
 			{
 				blocksbs = blocks << 11;
-				ioctl2(g_cache_path_fd, PIOCALLOC, &blocksbs, 4, 0, 0);
+				ioctl2(g_cache_path_fd, PIOCALLOC, &blocksbs, sizeof(blocksbs), 0, 0);
 			}
 			for ( i = 0; i < blocks; i += 1 )
 			{
@@ -3275,7 +3558,7 @@ void hex_dump(u8 *addr_start, int length)
 }
 #endif
 
-static int cdvdman_initcfg()
+static int cdvdman_initcfg(void)
 {
 	int i;
 	u8 m_version[5];
@@ -3286,7 +3569,11 @@ static int cdvdman_initcfg()
 	{
 		unsigned int mvored;
 
-		if ( !sceCdGetMVersion(m_version, &eflag) && (eflag & 0x80) )
+#ifdef CDVD_VARIANT_XOSD
+		if ( !sceCdMV(m_version, &eflag) )
+#else
+		if ( !sceCdMV(m_version, &eflag) && (eflag & 0x80) )
+#endif
 		{
 			vDelayThread(2000);
 			VERBOSE_KPRINTF(1, "_sceCdMV error\n");
@@ -3302,9 +3589,55 @@ static int cdvdman_initcfg()
 		g_cdvdman_minver_50200 = mvored >= 0x50200;
 		g_cdvdman_minver_50400 = mvored >= 0x50400;
 		g_cdvdman_minver_50600 = mvored >= 0x50600;
+#ifdef CDVD_VARIANT_XOSD
+		VERBOSE_KPRINTF(0, "M Version %02x %02x %02x %02x\n", m_version[0], m_version[1], m_version[2], m_version[3]);
+		if ( cdvdman_get_renewal_date(m_version, &eflag) )
+		{
+			VERBOSE_KPRINTF(
+				0,
+				"M Renewal Date 20%02x/%02x/%02x %02x:%02x\n",
+				m_version[0],
+				m_version[1],
+				m_version[2],
+				m_version[3],
+				m_version[4]);
+		}
+		g_cdvdman_vernotxxx1x = 0;
+		if ( g_cdvdman_minver_50600 )
+		{
+			// cdvdman_verxxxx1 = (mvored & 0xF) == 1; // not referenced!
+			KPRINTF("X_model ");
+			switch ( mvored & 0xF0 )
+			{
+				case 0x00:
+					KPRINTF("量産 OR 量産試作機\n");
+					break;
+				case 0x10:
+					KPRINTF("原理試作機\n");
+					g_cdvdman_vernotxxx1x = 1;
+					break;
+				case 0x20:
+					KPRINTF("手作り試作機\n");
+					break;
+				case 0x30:
+					KPRINTF("型物試作機\n");
+					break;
+				default:
+					KPRINTF("Unkown\n");
+					break;
+			}
+		}
+		else
+		{
+			KPRINTF("X_model 旧原理試作機 Ver5.6未満 Found\n");
+		}
+#endif
 		g_cdvdman_minver_x_model_15 = (mvored & 0xF) == 1;
 		g_cdvdman_minver_60000 = mvored >= 0x60000;
 		g_cdvdman_minver_60200 = mvored >= 0x60200;
+#ifdef CDVD_VARIANT_OSD
+		g_cdvdman_minver_60600 = mvored >= 0x60600;
+#endif
 		return 1;
 	}
 	return 0;
@@ -3342,6 +3675,36 @@ static int vReferEventFlagStatus(int ef, iop_event_info_t *info)
 	return (QueryIntrContext() ? iReferEventFlagStatus : ReferEventFlagStatus)(ef, info);
 }
 
+static int vPollEventFlag(int ef, u32 bits, int mode, u32 *efbits)
+{
+#ifdef CDVD_VARIANT_XOSD
+	int retres;
+	iop_event_info_t efinfo;
+
+	if ( !QueryIntrContext() )
+	{
+		return PollEventFlag(ef, bits, mode, efbits);
+	}
+	retres = iReferEventFlagStatus(ef, &efinfo);
+	if ( retres )
+	{
+		return retres;
+	}
+	*efbits = efinfo.currBits;
+	if ( (mode & 1) ? !(efinfo.currBits & bits) : ((efinfo.currBits & bits) != bits) )
+	{
+		return KE_EVF_COND;
+	}
+	if ( mode & 0x10 )
+	{
+		iClearEventFlag(ef, ~bits);
+	}
+	return 0;
+#else
+	return PollEventFlag(ef, bits, mode, efbits);
+#endif
+}
+
 static int vDelayThread(int usec)
 {
 	int intrval;
@@ -3352,10 +3715,145 @@ static int vDelayThread(int usec)
 	return (!QueryIntrContext() && !intrval) ? DelayThread(usec) : 0;
 }
 
-static int read_timeout_alarm_cb(const iop_sys_clock_t *sys_clock)
+#ifdef CDVD_VARIANT_XOSD
+static int get_cdvd_register(int regnr)
+{
+	int intrres;
+	int IntrContext;
+	int regval;
+	iop_event_info_t efinfo;
+	int state;
+	u32 efbits;
+
+	intrres = CpuSuspendIntr(&state);
+	CpuResumeIntr(state);
+	IntrContext = QueryIntrContext();
+	if ( !IntrContext && !intrres )
+	{
+		WaitEventFlag(g_cdvdman_csys_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+		CpuSuspendIntr(&state);
+	}
+	else
+	{
+		if ( IntrContext )
+		{
+			iReferEventFlagStatus(g_cdvdman_csys_evfid, &efinfo);
+		}
+		else
+		{
+			ReferEventFlagStatus(g_cdvdman_csys_evfid, &efinfo);
+		}
+		if ( !(efinfo.currBits & 1) )
+		{
+			return -1;
+		}
+	}
+	if ( update_cd_mode_ps2_atapi() != 1 )
+	{
+		regval = ((vu8 *)(0xBF402000))[regnr];
+	}
+	else
+	{
+		if ( !IntrContext && !intrres )
+		{
+			CpuResumeIntr(state);
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				WaitEventFlag(g_cd_atapi_evfid, 3, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				WaitEventFlag(g_adma_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			if ( g_acmd_evfid != -1 )
+			{
+				WaitEventFlag(g_acmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			CpuSuspendIntr(&state);
+		}
+		else
+		{
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				if ( IntrContext )
+				{
+					iReferEventFlagStatus(g_cd_atapi_evfid, &efinfo);
+				}
+				else
+				{
+					ReferEventFlagStatus(g_cd_atapi_evfid, &efinfo);
+				}
+				if ( !(efinfo.currBits & 3) )
+				{
+					return -1;
+				}
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				if ( IntrContext )
+				{
+					iReferEventFlagStatus(g_adma_evfid, &efinfo);
+				}
+				else
+				{
+					ReferEventFlagStatus(g_adma_evfid, &efinfo);
+				}
+				if ( !(efinfo.currBits & 1) )
+				{
+					return -1;
+				}
+			}
+			if ( g_acmd_evfid != -1 )
+			{
+				if ( IntrContext )
+				{
+					iReferEventFlagStatus(g_acmd_evfid, &efinfo);
+				}
+				else
+				{
+					ReferEventFlagStatus(g_acmd_evfid, &efinfo);
+				}
+			}
+			if ( !(efinfo.currBits & 1) )
+			{
+				return -1;
+			}
+		}
+		set_cdvd_dev5_base_addr_atapi(2);
+		regval = ((vu8 *)(0xBF402000))[regnr];
+		set_cdvd_dev5_base_addr_atapi(1);
+		if ( !IntrContext && !intrres )
+		{
+			if ( g_acmd_evfid != -1 )
+			{
+				SetEventFlag(g_acmd_evfid, 1);
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				SetEventFlag(g_adma_evfid, 1);
+			}
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				SetEventFlag(g_cd_atapi_evfid, 3);
+			}
+		}
+	}
+	if ( !IntrContext && !intrres )
+	{
+		CpuResumeIntr(state);
+		SetEventFlag(g_cdvdman_csys_evfid, 1);
+	}
+	return regval;
+}
+#endif
+
+// cppcheck-suppress constParameterCallback
+static unsigned int read_timeout_alarm_cb(void *userdata)
 {
 	int read_timeout;
+	const iop_sys_clock_t *sys_clock;
 
+	sys_clock = (const iop_sys_clock_t *)userdata;
 	read_timeout = sys_clock->lo / 0x9000;
 	KPRINTF("Read Time Out %d(msec)\n", read_timeout);
 	sceCdSC(0xFFFFFFEE, &read_timeout);
@@ -3364,37 +3862,53 @@ static int read_timeout_alarm_cb(const iop_sys_clock_t *sys_clock)
 
 sceCdCBFunc sceCdCallback(sceCdCBFunc function)
 {
-	void (*rc)(int);
+	sceCdCBFunc rc;
 	u32 efbits;
 
-	if ( sceCdSync(1) || PollEventFlag(g_ncmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( sceCdSync(1) || PollEventFlag(g_ncmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
 	rc = g_cdvdman_user_cb;
 	g_cdvdman_user_cb = function;
-	vSetEventFlag(g_ncmd_evid, 1);
+	vSetEventFlag(g_ncmd_evfid, 1);
 	return rc;
 }
 
-void *sceCdPOffCallback(void (*func)(void *), void *addr)
+// cppcheck-suppress funcArgNamesDifferent
+void *sceCdPOffCallback(void (*func)(void *), void *userdata)
 {
-	void (*old_cb)(void *);
+	void *old_cb;
 	int state;
 
 	CpuSuspendIntr(&state);
-	old_cb = g_cdvdman_poff_cb;
-	g_cdvdman_poff_cb = func;
-	g_cdvdman_poffarg = addr;
+	old_cb = g_cdvdman_power_off_callback;
+	g_cdvdman_power_off_callback = func;
+	g_cdvdman_power_off_callback_userdata = userdata;
 	CpuResumeIntr(state);
 	return old_cb;
 }
 
-int sceCdstm0Cb(void (*p)(int))
+#ifdef CDVD_VARIANT_XOSD
+void *sceCdSetAtapiEjectCallback(int (*func)(int, void *), void *userdata)
 {
-	g_cdvdman_cdstm0cb = p;
-	return 0;
-}
+	void *old_cb;
+	int state;
+
+	CpuSuspendIntr(&state);
+	old_cb = g_cdvdman_atapi_eject_bs_power_callback;
+	g_cdvdman_atapi_eject_bs_power_callback = func;
+	g_cdvdman_atapi_eject_bs_power_callback_userdata = userdata;
+	CpuResumeIntr(state);
+	return old_cb;
+}
+#endif
+
+int sceCdstm0Cb(void (*p)(int))
+{
+	g_cdvdman_cdstm0cb = p;
+	return 0;
+}
 
 int sceCdstm1Cb(void (*p)(int))
 {
@@ -3411,15 +3925,15 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 
 	ext_passthrough = 0;
 	s->m_wait_flag = s->m_waf_set_test;
-	iSetEventFlag(g_cdvdman_intr_efid, 0x29);
+	iSetEventFlag(g_cdvdman_intr_evfid, 0x29);
 	DisableIntr(IOP_IRQ_DMA_CDVD, &oldstate);
-	if ( *(u16 *)&s->m_cdvdman_command == 0x3105 )
+	if ( s->m_cdvdman_command == SCECdFuncStandby && s->m_last_error == SCECdErTRMOPN )
 	{
-		s->m_last_error = (sceCdStatus() == -1) ? SCECdErTRMOPN : 0;
+		s->m_last_error = (sceCdStatus() == SCECdErFAIL) ? SCECdErTRMOPN : SCECdErNO;
 	}
 	if ( s->m_last_error == SCECdErEOM )
 	{
-		s->m_last_error = 0;
+		s->m_last_error = SCECdErNO;
 	}
 	VERBOSE_KPRINTF(
 		1, "Intr call func_num: %d Err= %02x OnTout= %d\n", g_cdvdman_cmdfunc, (u8)s->m_last_error, s->m_last_read_timeout);
@@ -3429,7 +3943,7 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 	}
 	if (
 		(((u8)s->m_last_error == SCECdErREAD && g_cdvdman_cmdfunc == SCECdFuncRead)
-		 || ((u8)s->m_last_error == 1 && s->m_last_read_timeout && g_cdvdman_last_cmdfunc == 1))
+		 || ((u8)s->m_last_error == SCECdErABRT && s->m_last_read_timeout && g_cdvdman_last_cmdfunc == SCECdFuncRead))
 		&& !g_cdvdman_minver_20200 && !s->m_stream_flag && !s->m_dvd_flag && !s->m_recover_status
 		&& s->m_read_mode.trycount != 1 )
 	{
@@ -3472,8 +3986,8 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 		if ( dev5_reg_013_masked )
 		{
 			if (
-				((u8)s->m_last_error == 48 || ((u8)s->m_last_error == 1 && s->m_last_read_timeout)) && !s->m_recover_status
-				&& !s->m_stream_flag && g_cdvdman_cmdfunc != 9 && g_cdvdman_cmdfunc != SCECdFuncReadCDDA
+				((u8)s->m_last_error == SCECdErREAD || ((u8)s->m_last_error == SCECdErABRT && s->m_last_read_timeout))
+				&& !s->m_recover_status && !s->m_stream_flag && g_cdvdman_cmdfunc != 9 && g_cdvdman_cmdfunc != SCECdFuncReadCDDA
 				&& (unsigned int)s->m_read_mode.trycount - 1 >= 4 )
 			{
 				s->m_sync_error = 0;
@@ -3497,7 +4011,7 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 								 s->m_read_chunk,
 								 s->m_read_callback) )
 					{
-						s->m_last_error = 0;
+						s->m_last_error = SCECdErNO;
 						return 1;
 					}
 					s->m_last_error = SCECdErREAD;
@@ -3511,7 +4025,7 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 				s->m_sync_error = 0;
 				s->m_interupt_read_state = 0;
 				if (
-					s->m_last_error
+					s->m_last_error != SCECdErNO
 					|| !sceCdRead0_Rty(
 						s->m_dintrlsn,
 						(!s->m_read_chunk) ? s->m_read_sectors : s->m_read_chunk,
@@ -3535,7 +4049,7 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 				if ( sceCdRead0(
 							 s->m_read_lsn, s->m_read_sectors, s->m_read_buf, &s->m_read_mode, s->m_read_chunk, s->m_read_callback) )
 				{
-					s->m_last_error = 0;
+					s->m_last_error = SCECdErNO;
 					s->m_recover_status = 3;
 					return 1;
 				}
@@ -3551,7 +4065,7 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 	}
 	if ( ext_passthrough )
 	{
-		s->m_last_error = 0;
+		s->m_last_error = SCECdErNO;
 		s->m_dintrlsn += s->m_read_sectors;
 		s->m_read_chunk_reprocial_32 -= 1;
 		s->m_recover_status = (!s->m_read_chunk_reprocial_32) ? 2 : 1;
@@ -3583,9 +4097,9 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 			VERBOSE_KPRINTF(1, "Intr func0 no seting");
 		}
 	}
-	if ( s->m_stream_flag == 2 && !s->m_use_toc )
+	if ( !s->m_read2_flag )
 	{
-		if ( !s->m_read2_flag )
+		if ( s->m_stream_flag == 2 && !s->m_use_toc )
 		{
 			if ( g_cdvdman_cdstm1cb )
 			{
@@ -3596,14 +4110,12 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 				VERBOSE_KPRINTF(1, "Intr func1 no seting");
 			}
 		}
-	}
-	else
-	{
-		if ( !s->m_read2_flag )
+		else
 		{
 			g_cdvdman_readptr = 0;
 		}
 	}
+
 	VERBOSE_KPRINTF(
 		1, "Intr call user callback func_addr %08x num %d flg %d\n", g_cdvdman_user_cb, g_cdvdman_cmdfunc, s->m_read2_flag);
 	if ( g_cdvdman_user_cb && g_cdvdman_cmdfunc && !s->m_read2_flag && !s->m_use_toc )
@@ -3625,15 +4137,144 @@ static int cdvdman_intr_cb(cdvdman_internal_struct_t *s)
 	return 1;
 }
 
-static int intrh_cdrom(cdvdman_internal_struct_t *s)
+static int intrh_cdrom(void *userdata)
 {
 	int conds1;
 	iop_event_info_t efinfo;
+#ifdef CDVD_VARIANT_XOSD
+	int condaddr5;
+#endif
+	int intr_cb_res;
+	cdvdman_internal_struct_t *s;
 	USE_DEV5_MMIO_HWPORT();
 
+	s = (cdvdman_internal_struct_t *)userdata;
 	conds1 = 0;
+#ifdef CDVD_VARIANT_XOSD
+	if ( s->m_cd_mode_ps2_atapi == 1 )
+	{
+		int spd_intr_stat_cur;
+		int atapi_intr_reason;
+
+		VERBOSE_KPRINTF(1, "Atapi Intr Called %d\n", g_cdvdman_debug_atapi_intr++);
+		condaddr5 = (unsigned int)GetBaseAddress(5) == 0x1F402000;
+		set_cdvd_dev5_base_addr_atapi(1);
+		(void)*(vu16 *)0xBF410028;  // r_spd_intr_stat
+		set_cdvd_dev5_base_addr_atapi(2);
+		atapi_intr_reason = dev5_mmio_hwport->m_dev5_reg_008;
+		if ( (atapi_intr_reason & 1) )
+		{
+			conds1 = 1;
+			dev5_mmio_hwport->m_dev5_reg_008 = 1;
+			VERBOSE_KPRINTF(1, "ATAPI DRAGON CMDCMPL Interrupt\n");
+		}
+		if ( atapi_intr_reason & 4 )
+		{
+			dev5_mmio_hwport->m_dev5_reg_008 = 4;
+			conds1 = 1;
+			iSetEventFlag(g_cdvdman_intr_evfid, 4);
+			iSetEventFlag(g_cdvdman_intr_evfid, 0x10);
+			set_cdvd_dev5_base_addr_atapi(1);
+			VERBOSE_KPRINTF(1, "ATAPI POFFRDY Interrupt\n");
+			if ( g_cdvdman_power_off_callback )
+			{
+				g_cdvdman_power_off_callback(g_cdvdman_power_off_callback_userdata);
+			}
+			set_cdvd_dev5_base_addr_atapi(2);
+		}
+		if ( (atapi_intr_reason & 8) )
+		{
+			conds1 = 1;
+			dev5_mmio_hwport->m_dev5_reg_008 = 8;
+			if ( !s->m_medium_removal_state )
+			{
+				s->m_atapi_disk_ejected = 0;
+			}
+			set_cdvd_dev5_base_addr_atapi(1);
+			VERBOSE_KPRINTF(1, "ATAPI EJECT Interrupt\n");
+			if ( s->m_cd_atapi_intr_callback && !s->m_medium_removal_state )
+			{
+				VERBOSE_KPRINTF(1, "EJECT Stop Call\n");
+				s->m_cd_atapi_intr_callback(1);
+			}
+			iSetEventFlag(g_cdvdman_intr_evfid, 0x40);
+			if ( g_cdvdman_atapi_eject_bs_power_callback )
+			{
+				VERBOSE_KPRINTF(1, "ATAPI EJECT Callback %p\n", g_cdvdman_atapi_eject_bs_power_callback);
+				g_cdvdman_atapi_eject_bs_power_callback(1, g_cdvdman_atapi_eject_bs_power_callback_userdata);
+			}
+			set_cdvd_dev5_base_addr_atapi(2);
+		}
+		if ( (atapi_intr_reason & 0x10) )
+		{
+			dev5_mmio_hwport->m_dev5_reg_008 = 0x10;
+			conds1 = 1;
+			set_cdvd_dev5_base_addr_atapi(1);
+			VERBOSE_KPRINTF(1, "ATAPI BS_Power DET Interrupt\n");
+			iSetEventFlag(g_cdvdman_intr_evfid, 0x80);
+			if ( g_cdvdman_atapi_eject_bs_power_callback )
+			{
+				VERBOSE_KPRINTF(1, "ATAPI BS_Power Callback %p\n", g_cdvdman_atapi_eject_bs_power_callback);
+				g_cdvdman_atapi_eject_bs_power_callback(2, g_cdvdman_atapi_eject_bs_power_callback_userdata);
+			}
+		}
+		set_cdvd_dev5_base_addr_atapi(1);
+		if ( g_cdvdman_vernotxxx1x && conds1 )
+		{
+			*(vu16 *)0xBF41002A &= ~0x100;  // r_spd_intr_mask
+			*(vu16 *)0xBF41002A |= 0x100;   // r_spd_intr_mask
+			(void)*(vu16 *)0xBF41002A;      // r_spd_intr_mask
+		}
+		spd_intr_stat_cur = *(vu16 *)0xBF410028;  // r_spd_intr_stat
+		VERBOSE_KPRINTF(
+			1,
+			"Atapi Intr Mode:%d addr:%08x Reason:%02x SPD_INTR_STAT %x\n",
+			s->m_cd_mode_ps2_atapi,
+			s->m_cd_atapi_intr_callback,
+			atapi_intr_reason,
+			spd_intr_stat_cur);
+		if ( (spd_intr_stat_cur & 3) && (*g_cdvdreg_bf80146c & 4) )
+		{
+			if ( s->m_cd_atapi_intr_callback )
+			{
+				s->m_cd_atapi_intr_callback(0);
+				VERBOSE_KPRINTF(1, "Atapi Intr called\n");
+			}
+			if ( !s->m_scmd_flag )
+			{
+				VERBOSE_KPRINTF(1, "Intr call set_prev_command.\n");
+				set_cdvd_dev5_base_addr_atapi(2);
+				cdvdman_write_scmd(s);
+				set_cdvd_dev5_base_addr_atapi(1);
+			}
+		}
+		else if ( !conds1 )
+		{
+			if ( (*g_cdvdreg_bf80146c & 4) )
+			{
+				VERBOSE_KPRINTF(1, "No_Reason Intr\n");
+			}
+			else
+			{
+				VERBOSE_KPRINTF(1, "already 9611 Power Off Intr\n");
+			}
+		}
+		if ( condaddr5 )
+		{
+			set_cdvd_dev5_base_addr_atapi(2);
+			VERBOSE_KPRINTF(1, "Cur PS2 IO Intr Called\n");
+		}
+		return 1;
+	}
+	VERBOSE_KPRINTF(1, "Dragon Intr Called\n");
+	condaddr5 = (unsigned int)GetBaseAddress(5) == 0xBF410000;
+	if ( condaddr5 )
+	{
+		set_cdvd_dev5_base_addr_atapi(2);
+	}
+#endif
 	s->m_waf_set_test = s->m_wait_flag;
-	if ( (u8)s->m_last_error != 1 )
+	if ( (u8)s->m_last_error != SCECdErABRT )
 	{
 		s->m_last_error = dev5_mmio_hwport->m_dev5_reg_006;
 	}
@@ -3646,11 +4287,13 @@ static int intrh_cdrom(cdvdman_internal_struct_t *s)
 	if ( (dev5_mmio_hwport->m_dev5_reg_008 & 4) )
 	{
 		dev5_mmio_hwport->m_dev5_reg_008 = 4;
-		iSetEventFlag(g_cdvdman_intr_efid, 4);
-		iSetEventFlag(g_cdvdman_intr_efid, 0x10);
-		if ( g_cdvdman_poff_cb )
+		iSetEventFlag(g_cdvdman_intr_evfid, 4);
+		iSetEventFlag(g_cdvdman_intr_evfid, 0x10);
+		// The following Kprintf was added for ioprp300x
+		VERBOSE_KPRINTF(1, "PS2 POWER OFF Interrupt\n");
+		if ( g_cdvdman_power_off_callback )
 		{
-			g_cdvdman_poff_cb(g_cdvdman_poffarg);
+			g_cdvdman_power_off_callback(g_cdvdman_power_off_callback_userdata);
 		}
 		if ( !conds1 )
 		{
@@ -3663,12 +4306,48 @@ static int intrh_cdrom(cdvdman_internal_struct_t *s)
 		s->m_ncmd_intr_count += 1;
 		dev5_mmio_hwport->m_dev5_reg_008 = 2;
 	}
-	iReferEventFlagStatus(g_cdvdman_intr_efid, &efinfo);
+#ifdef CDVD_VARIANT_XOSD
+	if ( (dev5_mmio_hwport->m_dev5_reg_008 & 8) )
+	{
+		dev5_mmio_hwport->m_dev5_reg_008 = 8;
+		VERBOSE_KPRINTF(1, "PS2 EJECT Interrupt\n");
+		iSetEventFlag(g_cdvdman_intr_evfid, 0x40);
+		if ( !s->m_medium_removal_state )
+		{
+			s->m_atapi_disk_ejected = 0;
+		}
+		if ( g_cdvdman_atapi_eject_bs_power_callback )
+		{
+			VERBOSE_KPRINTF(1, "PS2 EJECT Callback %p\n", g_cdvdman_atapi_eject_bs_power_callback);
+			g_cdvdman_atapi_eject_bs_power_callback(1, g_cdvdman_atapi_eject_bs_power_callback_userdata);
+		}
+	}
+	if ( (dev5_mmio_hwport->m_dev5_reg_008 & 0x10) )
+	{
+		dev5_mmio_hwport->m_dev5_reg_008 = 0x10;
+		VERBOSE_KPRINTF(1, "PS2 BS_Power DET Interrupt\n");
+		iSetEventFlag(g_cdvdman_intr_evfid, 0x80);
+		if ( g_cdvdman_atapi_eject_bs_power_callback )
+		{
+			VERBOSE_KPRINTF(1, "PS2 BS_Power Callback %p\n", g_cdvdman_atapi_eject_bs_power_callback);
+			g_cdvdman_atapi_eject_bs_power_callback(2, g_cdvdman_atapi_eject_bs_power_callback_userdata);
+		}
+	}
+#endif
+	iReferEventFlagStatus(g_cdvdman_intr_evfid, &efinfo);
 	if ( !(efinfo.currBits & 0x20) )
 	{
-		if ( !s->m_last_error )
+		// The following Kprintf was added for ioprp300x
+		VERBOSE_KPRINTF(1, "Now DMA Working evfid:%08x\n", efinfo.currBits);
+		if ( s->m_last_error == SCECdErNO )
 		{
 			s->m_drive_interupt_request = 1;
+#ifdef CDVD_VARIANT_XOSD
+			if ( condaddr5 )
+			{
+				set_cdvd_dev5_base_addr_atapi(1);
+			}
+#endif
 			return 1;
 		}
 		if ( s->m_last_error == SCECdErEOM )
@@ -3676,7 +4355,14 @@ static int intrh_cdrom(cdvdman_internal_struct_t *s)
 			intrh_dma_3(s);
 		}
 	}
-	return cdvdman_intr_cb(s);
+	intr_cb_res = cdvdman_intr_cb(s);
+#ifdef CDVD_VARIANT_XOSD
+	if ( condaddr5 )
+	{
+		set_cdvd_dev5_base_addr_atapi(1);
+	}
+#endif
+	return intr_cb_res;
 }
 
 static u32 cdvdman_l1start(const u8 *toc)
@@ -3684,9 +4370,14 @@ static u32 cdvdman_l1start(const u8 *toc)
 	return toc[23] + (toc[22] << 8) + (toc[21] << 16) - 0x30000 + 1;
 }
 
-static int DvdDual_infochk()
+static int DvdDual_infochk(void)
 {
+#ifdef CDVD_VARIANT_OSD
+	// From DVD Player 3.11
 	if ( QueryIntrContext() || !(cdvdman_mediactl(3) || (u8)g_cdvdman_istruct.m_opo_or_para == 0xFF) )
+#else
+	if ( QueryIntrContext() || !(cdvdman_mediactl(4) || (u8)g_cdvdman_istruct.m_opo_or_para == 0xFF) )
+#endif
 	{
 		return 1;
 	}
@@ -3762,7 +4453,7 @@ static u32 sceCdLsnDualChg(u32 lsn)
 
 						read0_result = sceCdRead0(0xE, 1, g_cdvdman_ptoc, &cdrmode, 0, 0);
 						sceCdSync(3);
-						if ( !g_cdvdman_istruct.m_last_error || read0_result )
+						if ( g_cdvdman_istruct.m_last_error == SCECdErNO || read0_result )
 						{
 							int i;
 
@@ -3841,10 +4532,12 @@ int sceCdReadDvdDualInfo(int *on_dual, unsigned int *layer1_start)
 	*on_dual = 0;
 	*layer1_start = 0;
 	g_cdvdman_istruct.m_dual_layer_emulation = 0;
+#ifndef CDVD_VARIANT_XOSD
 	if ( !cdvdman_isdvd() )
 	{
 		return 1;
 	}
+#endif
 	if ( !g_cdvdman_emudvd9 )
 	{
 		if ( !DvdDual_infochk() )
@@ -3855,16 +4548,24 @@ int sceCdReadDvdDualInfo(int *on_dual, unsigned int *layer1_start)
 		*layer1_start = g_cdvdman_istruct.m_layer_1_lsn;
 		return 1;
 	}
+#ifdef CDVD_VARIANT_OSD
+	if ( !cdvdman_isdvd() )
+	{
+		return 1;
+	}
+#endif
+#ifndef CDVD_VARIANT_XOSD
 	if ( g_cdvdman_mmode != SCECdMmodeDvd && g_cdvdman_mmode != 0xFF )
 	{
 		return 0;
 	}
+#endif
 	cdrmode.trycount = 0;
 	cdrmode.spindlctrl = SCECdSpinStm;
 	cdrmode.datapattern = SCECdSecS2048;
 	read0_result = sceCdRead0(0xE, 1, g_cdvdman_ptoc, &cdrmode, 0, 0);
 	sceCdSync(3);
-	if ( g_cdvdman_istruct.m_last_error && !read0_result )
+	if ( g_cdvdman_istruct.m_last_error != SCECdErNO && !read0_result )
 	{
 		VERBOSE_KPRINTF(1, "CDVD: ReadDvdDualInfo Read Error %02x, %d\n", (u8)g_cdvdman_istruct.m_last_error, 0);
 		return 0;
@@ -3912,17 +4613,71 @@ int sceCdSC(int code, int *param)
 	int *BootMode;
 	int state;
 	u32 efbits;
+#ifdef CDVD_VARIANT_XOSD
+	u8 regval;
+#endif
 
 	switch ( code )
 	{
+#ifdef CDVD_VARIANT_XOSD
+		case 0xFFFFFFD6:
+			CpuSuspendIntr(&state);
+			set_cdvd_dev5_base_addr_atapi(2);
+			regval = ((vu8 *)(0xBF402000))[*param];
+			set_cdvd_dev5_base_addr_atapi(1);
+			CpuResumeIntr(state);
+			return regval;
+		case 0xFFFFFFD7:
+			CpuSuspendIntr(&state);
+			*param = (int)&g_cdvdman_istruct.m_chgsys_writer_drive_shell_is_open;
+			CpuResumeIntr(state);
+			return 1;
+		case 0xFFFFFFD8:
+			return sc_ffffffd8((u32 *)param);
+		case 0xFFFFFFD9:
+			CpuSuspendIntr(&state);
+			*param = (int)&g_cdvdman_istruct.m_atapi_disk_ejected;
+			CpuResumeIntr(state);
+			return 1;
+		case 0xFFFFFFDA:
+			return get_disk_type_ex();
+		case 0xFFFFFFDB:
+			CpuSuspendIntr(&state);
+			*(&g_cdvdman_istruct.m_var_sc_ffffffdb) = (int)param;
+			CpuResumeIntr(state);
+			return 1;
+		case 0xFFFFFFDC:
+			return g_cdvdman_vernotxxx1x;
+		case 0xFFFFFFDD:
+			return get_cdvd_register(*param);
+		case 0xFFFFFFDF:
+			g_adma_evfid = *param;
+			return 1;
+		case 0xFFFFFFE0:
+			g_acmd_evfid = *param;
+			return 1;
+		case 0xFFFFFFE1:
+			CpuSuspendIntr(&state);
+			g_cdvdman_istruct.m_chgsys_callback = (void *)(int)param;
+			CpuResumeIntr(state);
+			return 1;
+		case 0xFFFFFFE4:
+			g_cd_atapi_evfid = *param;
+			return 1;
+		case 0xFFFFFFE5:
+			CpuSuspendIntr(&state);
+			g_cdvdman_istruct.m_cd_atapi_intr_callback = (void *)(int)param;
+			CpuResumeIntr(state);
+			return 1;
+#endif
 		case 0xFFFFFFE6:
 			CpuSuspendIntr(&state);
-			*param = (int)g_cdvdman_poff_cb;
-			poffarg_tmp = g_cdvdman_poffarg;
+			*param = (int)g_cdvdman_power_off_callback;
+			poffarg_tmp = g_cdvdman_power_off_callback_userdata;
 			CpuResumeIntr(state);
 			return (int)poffarg_tmp;
 		case 0xFFFFFFE7:
-			return g_scmd_evid;
+			return g_scmd_evfid;
 		case 0xFFFFFFE9:
 			return sceCdLsnDualChg(*param);
 		case 0xFFFFFFEA:
@@ -3942,22 +4697,24 @@ int sceCdSC(int code, int *param)
 			return 0xFF;
 		case 0xFFFFFFF3:
 			BootMode = QueryBootMode(4);
-			if ( BootMode )
+			switch ( BootMode ? *(u8 *)BootMode : 0xFF )
 			{
-				switch ( *(u8 *)BootMode )
-				{
-					case 0:
-					case 1:
-					case 2:
-						g_cdvdman_mmode = 0xFF;
-						break;
-					case 3:
-						g_cdvdman_mmode = SCECdMmodeCd;
-						break;
-				}
+				case 0:
+				case 1:
+				case 2:
+					g_cdvdman_mmode = 0xFF;
+					break;
+				case 3:
+					g_cdvdman_mmode = SCECdMmodeCd;
+					break;
+				default:
+					break;
 			}
 			return 1;
 		case 0xFFFFFFF4:
+#ifdef CDVD_VARIANT_OSD
+			return 1;
+#else
 			// The following call to sceCdGetDiskType was inlined
 			switch ( sceCdGetDiskType() )
 			{
@@ -3973,16 +4730,17 @@ int sceCdSC(int code, int *param)
 				default:
 					return 0;
 			}
+#endif
 		case 0xFFFFFFF5:
-			return g_cdvdman_intr_efid;
+			return g_cdvdman_intr_evfid;
 		case 0xFFFFFFF6:
 			if ( *param )
 			{
-				WaitEventFlag(g_fio_fsv_evid, 1, WEF_AND | WEF_CLEAR, &efbits);
+				WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
 			}
 			else
 			{
-				SetEventFlag(g_fio_fsv_evid, 1);
+				SetEventFlag(g_fio_fsv_evfid, 1);
 			}
 			g_cdvdman_ee_rpc_fno = *param;
 			VERBOSE_KPRINTF(1, "EE_ncmd_working code= %d\n", *param);
@@ -4015,24 +4773,46 @@ int sceCdSC(int code, int *param)
 	}
 }
 
-static void cdvdman_init()
+static void cdvdman_init(void)
 {
 	int *BootMode;
 	unsigned int i;
 	int scres_unused;
 	u32 argres;
+#ifdef CDVD_VARIANT_XOSD
+	int chgsys_tmp;
+#endif
 	USE_DEV5_MMIO_HWPORT();
 
+#ifdef CDVD_VARIANT_XOSD
+	{
+		int state;
+		CpuSuspendIntr(&state);
+		g_cdvdman_istruct.m_cd_mode_ps2_atapi = 2;
+		cdvdman_change_drive(2);
+		CpuResumeIntr(state);
+	}
+#endif
 	g_cdvdman_user_cb = 0;
-	g_cdvdman_poff_cb = 0;
+	g_cdvdman_power_off_callback = 0;
 	g_cdvdman_cmdfunc = 0;
 	g_cdvdman_istruct.m_drive_interupt_request = 0;
-	RegisterIntrHandler(IOP_IRQ_CDVD, 1, (int (*)(void *))intrh_cdrom, &g_cdvdman_istruct);
-	RegisterIntrHandler(IOP_IRQ_DMA_CDVD, 1, (int (*)(void *))intrh_dma_3, &g_cdvdman_istruct);
+	RegisterIntrHandler(IOP_IRQ_CDVD, 1, intrh_cdrom, &g_cdvdman_istruct);
+	RegisterIntrHandler(IOP_IRQ_DMA_CDVD, 1, intrh_dma_3, &g_cdvdman_istruct);
 	EnableIntr(IOP_IRQ_CDVD);
 	sceCdSC(0xFFFFFFF3, &scres_unused);
 	dmac_set_dpcr(dmac_get_dpcr() | 0x8000);
 	dmac_ch_set_chcr(3, 0);
+#ifdef CDVD_VARIANT_XOSD
+	if ( (dev5_mmio_hwport->m_dev5_reg_008 & 0x10) )
+	{
+		dev5_mmio_hwport->m_dev5_reg_008 = 0x10;
+	}
+	if ( (dev5_mmio_hwport->m_dev5_reg_008 & 8) )
+	{
+		dev5_mmio_hwport->m_dev5_reg_008 = 8;
+	}
+#endif
 	if ( (dev5_mmio_hwport->m_dev5_reg_008 & 4) )
 	{
 		dev5_mmio_hwport->m_dev5_reg_008 = 4;
@@ -4041,8 +4821,13 @@ static void cdvdman_init()
 	{
 		dev5_mmio_hwport->m_dev5_reg_008 = 1;
 	}
+#ifndef CDVD_VARIANT_XOSD
+	g_cdvdman_clk_flg = sceCdReadClock(&g_cdvdman_clock) ? (!g_cdvdman_clock.stat) : 0;
+#endif
+	g_cdvdman_istruct.m_tray_is_open = !(dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen);
+#ifdef CDVD_VARIANT_XOSD
 	g_cdvdman_clk_flg = sceCdReadClock(&g_cdvdman_clock) ? (!g_cdvdman_clock.stat) : 0;
-	g_cdvdman_istruct.m_tray_is_open = (dev5_mmio_hwport->m_dev5_reg_00A ^ 1) & 1;
+#endif
 	cdvdman_initcfg();
 	BootMode = QueryBootMode(6);
 	g_cdvdman_istruct.m_no_dec_flag = BootMode ? ((*(u16 *)BootMode & 0xFFFC) == 0x60) : 0;
@@ -4050,21 +4835,51 @@ static void cdvdman_init()
 	{
 		DelayThread(16000);
 	}
+#ifdef CDVD_VARIANT_XOSD
+	{
+		u32 medium_res;
+		int MediumRemoval;
+
+		for ( i = 0; i <= 60 && (!sceCdSetMediumRemoval(0, &argres) || argres); i += 1 )
+		{
+			DelayThread(16000);
+		}
+		for ( i = 0; i <= 60 && (!(MediumRemoval = sceCdGetMediumRemoval(&medium_res, &argres)) || argres); i += 1 )
+		{
+			DelayThread(16000);
+		}
+		g_cdvdman_istruct.m_medium_removal_state = (MediumRemoval && !argres) ? medium_res : 0;
+		{
+			int state;
+
+			CpuSuspendIntr(&state);
+			chgsys_tmp = (dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen);
+			g_cdvdman_istruct.m_cd_mode_ps2_atapi =
+				(chgsys_tmp || (!(dev5_mmio_hwport->m_dev5_reg_015 & 0x80) && dev5_mmio_hwport->m_dev5_reg_00F != 6)) ? 2 : 1;
+			cdvdman_change_drive(g_cdvdman_istruct.m_cd_mode_ps2_atapi);
+			CpuResumeIntr(state);
+		}
+		if ( chgsys_tmp )
+		{
+			sceCdChgSys(1);
+		}
+	}
+#endif
 }
 
 int sceCdInit(int mode)
 {
-	USE_DEV5_MMIO_HWPORT();
-
 	VERBOSE_PRINTF(1, "sceCdInit called mode= %d\n", mode);
 	if ( mode == SCECdEXIT )
 	{
 		int oldstate;
 
 		g_cdvdman_istruct.m_cd_inited = 0;
+#ifndef CDVD_VARIANT_XOSD
 		sceCdBreak();
 		sceCdSync(3);
 		cdvdman_ncmd_sender_06();
+#endif
 		sceCdSync(0);
 		VERBOSE_PRINTF(1, "Cdvdman Exit\n");
 		DisableIntr(IOP_IRQ_CDVD, &oldstate);
@@ -4079,7 +4894,12 @@ int sceCdInit(int mode)
 		g_cdvdman_istruct.m_dec_shift = 0;
 		g_cdvdman_istruct.m_check_version = 0;
 		g_cdvdman_istruct.m_dec_state = 0;
-		sceCdDecSet(0, 0, 0);
+#ifdef CDVD_VARIANT_XOSD
+		if ( update_cd_mode_ps2_atapi() != 1 )
+#endif
+		{
+			sceCdDecSet(0, 0, 0);
+		}
 		cdvdman_init();
 		g_cdvdman_istruct.m_cd_inited = 1;
 	}
@@ -4087,31 +4907,40 @@ int sceCdInit(int mode)
 	{
 		u8 ready_status_tmp;
 		u8 ready_status;
-		int ready_status_mask_c0h;
 
 		ready_status_tmp = 0;
 		VERBOSE_PRINTF(1, "sceCdInit Ready check start.\n");
-		for ( ready_status_mask_c0h = 0; ready_status_mask_c0h != 0x40; ready_status_mask_c0h = ready_status & 0xC0 )
+		ready_status = 0;
+		while ( (ready_status & 0xC0) != 0x40 )
 		{
-			ready_status = dev5_mmio_hwport->m_dev5_reg_005;
+#ifdef CDVD_VARIANT_XOSD
+			if ( update_cd_mode_ps2_atapi() == 1 || sceCdGetDiskType() == 6 )
+				break;
+			g_cdvdman_istruct.m_field_0DC = 0;
+			if ( sceCdGetDiskType() == SCECdNODISC )
+				break;
+#endif
+			ready_status = sceCdDiskReady(8);
 			vDelayThread(10000);
 			if ( ready_status != ready_status_tmp )
 			{
 				ready_status_tmp = ready_status;
 				VERBOSE_PRINTF(1, "sceCdInit Dev5 Status %x\n", ready_status);
 			}
+			// The following Kprintf was added for ioprp300x
+			VERBOSE_PRINTF(1, "sceCdInit Ready check %x\n", ready_status);
 		}
 		VERBOSE_PRINTF(1, "sceCdInit Ready check end.\n");
 	}
 	g_cdvdman_istruct.m_wait_flag = 1;
 	g_cdvdman_istruct.m_scmd_flag = 1;
-	g_cdvdman_istruct.m_last_error = 0;
+	g_cdvdman_istruct.m_last_error = SCECdErNO;
 	g_cdvdman_istruct.m_last_read_timeout = 0;
 	g_cdvdman_spinctl = -1;
-	SetEventFlag(g_cdvdman_intr_efid, 0x29);
-	SetEventFlag(g_ncmd_evid, 1);
-	SetEventFlag(g_scmd_evid, 1);
-	SetEventFlag(g_sfile_evid, 1);
+	SetEventFlag(g_cdvdman_intr_evfid, 0x29);
+	SetEventFlag(g_ncmd_evfid, 1);
+	SetEventFlag(g_scmd_evfid, 1);
+	SetEventFlag(g_sfile_evfid, 1);
 	return 1;
 }
 
@@ -4121,9 +4950,34 @@ static int set_prev_command(int cmd, const char *sdata, int sdlen, char *rdata,
 	int delaybackoff;
 	int j;
 	u32 efbits;
+#ifdef CDVD_VARIANT_XOSD
+	int suspendres;
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+	{
+		int state;
 
-	if ( check_sef == 1 && PollEventFlag(g_scmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+		suspendres = CpuSuspendIntr(&state);
+		CpuResumeIntr(state);
+		suspendres = QueryIntrContext() || suspendres;
+	}
+	VERBOSE_KPRINTF(1, "set_prev_command cmd %02x call\n", cmd);
+	if ( !suspendres )
+	{
+		WaitEventFlag(g_cdvdman_csys_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	}
+#endif
+	if ( check_sef == 1 && vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
+		// The following Kprintf was added for ioprp300x
+		VERBOSE_KPRINTF(1, "set_prev_command Double Booking\n");
+#ifdef CDVD_VARIANT_XOSD
+		if ( !suspendres )
+		{
+			SetEventFlag(g_cdvdman_csys_evfid, 1);
+		}
+#endif
 		return 0;
 	}
 	g_cdvdman_istruct.m_scmd = cmd;
@@ -4133,24 +4987,75 @@ static int set_prev_command(int cmd, const char *sdata, int sdlen, char *rdata,
 	{
 		g_cdvdman_istruct.m_scmd_sd[i] = sdata[i];
 	}
-	if ( g_cdvdman_istruct.m_wait_flag )
-	{
-		g_cdvdman_istruct.m_scmd_flag = 1;
-		cdvdman_write_scmd(&g_cdvdman_istruct);
-	}
-	else if ( QueryIntrContext() )
+#ifdef CDVD_VARIANT_XOSD
+	if ( update_cd_mode_ps2_atapi() != 1 )
+#endif
 	{
-		while ( (dmac_ch_get_chcr(3) & 0x1000000) && !g_cdvdman_istruct.m_wait_flag )
+		if ( g_cdvdman_istruct.m_wait_flag )
+		{
+			g_cdvdman_istruct.m_scmd_flag = 1;
+			cdvdman_write_scmd(&g_cdvdman_istruct);
+		}
+		else if ( QueryIntrContext() )
+		{
+			while ( (dmac_ch_get_chcr(3) & 0x1000000) && !g_cdvdman_istruct.m_wait_flag )
+			{
+				VERBOSE_KPRINTF(1, "set_prev_command: DMA Wait\n");
+			}
+			g_cdvdman_istruct.m_scmd_flag = 1;
+			cdvdman_write_scmd(&g_cdvdman_istruct);
+		}
+		else
 		{
-			VERBOSE_KPRINTF(1, "set_prev_command: DMA Wait\n");
+			g_cdvdman_istruct.m_scmd_flag = 0;
 		}
-		g_cdvdman_istruct.m_scmd_flag = 1;
-		cdvdman_write_scmd(&g_cdvdman_istruct);
 	}
+#ifdef CDVD_VARIANT_XOSD
 	else
 	{
-		g_cdvdman_istruct.m_scmd_flag = 0;
+		if ( !suspendres )
+		{
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				WaitEventFlag(g_cd_atapi_evfid, 3, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				WaitEventFlag(g_adma_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			if ( g_acmd_evfid != -1 )
+			{
+				WaitEventFlag(g_acmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			}
+		}
+		{
+			int state;
+
+			CpuSuspendIntr(&state);
+			set_cdvd_dev5_base_addr_atapi(2);
+			g_cdvdman_istruct.m_scmd_flag = 1;
+			VERBOSE_KPRINTF(1, "do_set_prev_command %02x\n", cmd);
+			cdvdman_write_scmd(&g_cdvdman_istruct);
+			set_cdvd_dev5_base_addr_atapi(1);
+			CpuResumeIntr(state);
+		}
+		if ( !suspendres )
+		{
+			if ( g_acmd_evfid != -1 )
+			{
+				SetEventFlag(g_acmd_evfid, 1);
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				SetEventFlag(g_adma_evfid, 1);
+			}
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				SetEventFlag(g_cd_atapi_evfid, 3);
+			}
+		}
 	}
+#endif
 	delaybackoff = 1;
 	for ( i = 0; i < 500; i += delaybackoff )
 	{
@@ -4162,8 +5067,15 @@ static int set_prev_command(int cmd, const char *sdata, int sdlen, char *rdata,
 			}
 			if ( check_sef == 1 )
 			{
-				vSetEventFlag(g_scmd_evid, 1);
+				vSetEventFlag(g_scmd_evfid, 1);
+			}
+#ifdef CDVD_VARIANT_XOSD
+			VERBOSE_KPRINTF(1, "set_prev_command end :%02x\n", (u8)g_cdvdman_istruct.m_scmd);
+			if ( !suspendres )
+			{
+				SetEventFlag(g_cdvdman_csys_evfid, 1);
 			}
+#endif
 			return (u8)g_cdvdman_istruct.m_scmd;
 		}
 		vDelayThread(1000 * delaybackoff);
@@ -4175,7 +5087,7 @@ static int set_prev_command(int cmd, const char *sdata, int sdlen, char *rdata,
 	g_cdvdman_istruct.m_scmd_flag = 1;
 	if ( check_sef == 1 )
 	{
-		vSetEventFlag(g_scmd_evid, 1);
+		vSetEventFlag(g_scmd_evfid, 1);
 	}
 	return 0;
 }
@@ -4188,13 +5100,23 @@ static void cdvdman_write_scmd(cdvdman_internal_struct_t *s)
 	char rdptr1[64];
 	USE_DEV5_MMIO_HWPORT();
 
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "in:%d out_size:%d \n", (u8)s->m_sdlen, (u8)s->m_rdlen);
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "cmd:%02x pram:%02x\n", (u8)s->m_scmd, (u8)s->m_scmd_sd[0]);
 	for ( i = 0; i <= 0; i += 1 )
 	{
 		int overflowcond;
+#ifdef CDVD_VARIANT_XOSD
+		int suspendres;
+#endif
 
 		if ( (dev5_mmio_hwport->m_dev5_reg_017 & 0x80) )
 		{
-			*(u16 *)&s->m_scmd_flag = 1;
+			s->m_scmd_flag = 1;
+			s->m_scmd = 0;
+			// The following Kprintf was added for ioprp300x
+			VERBOSE_KPRINTF(1, "do_set_prev_command BUSY ABNORM END %08x\n", dev5_mmio_hwport->m_dev5_reg_017);
 			return;
 		}
 		while ( !(dev5_mmio_hwport->m_dev5_reg_017 & 0x40) )
@@ -4206,13 +5128,26 @@ static void cdvdman_write_scmd(cdvdman_internal_struct_t *s)
 			dev5_mmio_hwport->m_dev5_reg_017 = s->m_scmd_sd[j];
 		}
 		dev5_mmio_hwport->m_dev5_reg_016 = s->m_scmd;
+#ifdef CDVD_VARIANT_XOSD
+		{
+			int state;
+			suspendres = CpuSuspendIntr(&state);
+			CpuResumeIntr(state);
+			suspendres = QueryIntrContext() || suspendres;
+		}
+#endif
+#ifdef CDVD_VARIANT_XOSD
+		if ( suspendres )
+#else
 		if ( QueryIntrContext() )
+#endif
 		{
 			for ( j = 0; dev5_mmio_hwport->m_dev5_reg_017 & 0x80; j += 1 )
 			{
 				if ( j > 12500000 )
 				{
-					*(u16 *)&s->m_scmd_flag = 1;
+					s->m_scmd_flag = 1;
+					s->m_scmd = 0;
 					return;
 				}
 			}
@@ -4224,7 +5159,10 @@ static void cdvdman_write_scmd(cdvdman_internal_struct_t *s)
 				DelayThread(100);
 				if ( j > 50000 )
 				{
-					*(u16 *)&s->m_scmd_flag = 1;
+					// The following Kprintf was added for ioprp300x
+					VERBOSE_KPRINTF(1, "Mecacon Scmd TIMEOUT CMD= %02x\n", (u8)s->m_scmd);
+					s->m_scmd_flag = 1;
+					s->m_scmd = 0;
 					return;
 				}
 			}
@@ -4252,7 +5190,8 @@ static void cdvdman_write_scmd(cdvdman_internal_struct_t *s)
 	}
 	if ( i == 1 )
 	{
-		*(u16 *)&s->m_scmd_flag = 1;
+		s->m_scmd_flag = 1;
+		s->m_scmd = 0;
 	}
 	else
 	{
@@ -4273,27 +5212,41 @@ static void cdvdman_write_scmd(cdvdman_internal_struct_t *s)
 	}
 }
 
-static int cdvdman_send_scmd2(int cmd, const void *sdata, int sdlen, void *rdata, int rdlen, int check_sef)
+#ifdef CDVD_VARIANT_XOSD
+static int cdvdman_write_scmd_swap_dev5(char cmd, const char *wdata, int sdlen, char *rdata, int rdlen, int check_sef)
 {
+	int atapi_check;
 	int i;
 	int j;
 	char rdstart[64];
 	u32 efbits;
+	int state;
 	USE_DEV5_MMIO_HWPORT();
 
-	if ( check_sef == 1 && PollEventFlag(g_scmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( check_sef == 1 && vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
+	CpuSuspendIntr(&state);
+	atapi_check = update_cd_mode_ps2_atapi() == 1;
+	if ( atapi_check )
+	{
+		set_cdvd_dev5_base_addr_atapi(2);
+	}
 	for ( i = 0; i <= 0; i += 1 )
 	{
 		int cmdresoverflow;
 
 		if ( (dev5_mmio_hwport->m_dev5_reg_017 & 0x80) )
 		{
+			if ( atapi_check )
+			{
+				set_cdvd_dev5_base_addr_atapi(1);
+			}
+			CpuResumeIntr(state);
 			if ( check_sef == 1 )
 			{
-				vSetEventFlag(g_scmd_evid, 1);
+				vSetEventFlag(g_scmd_evfid, 1);
 			}
 			return 0;
 		}
@@ -4303,12 +5256,12 @@ static int cdvdman_send_scmd2(int cmd, const void *sdata, int sdlen, void *rdata
 		}
 		for ( j = 0; j < sdlen; j += 1 )
 		{
-			dev5_mmio_hwport->m_dev5_reg_017 = ((u8 *)sdata)[j];
+			dev5_mmio_hwport->m_dev5_reg_017 = wdata[j];
 		}
 		dev5_mmio_hwport->m_dev5_reg_016 = cmd;
 		while ( (dev5_mmio_hwport->m_dev5_reg_017 & 0x80) )
 		{
-			DelayThread(100);
+			;
 		}
 		cmdresoverflow = 0;
 		for ( j = 0; !(dev5_mmio_hwport->m_dev5_reg_017 & 0x40); j += 1 )
@@ -4316,7 +5269,7 @@ static int cdvdman_send_scmd2(int cmd, const void *sdata, int sdlen, void *rdata
 			if ( j >= rdlen )
 			{
 				cmdresoverflow = 1;
-				VERBOSE_KPRINTF(1, "Prev Cmd Result Over Flow\n");
+				VERBOSE_KPRINTF(1, "Prev Cmd2 Result Over Flow\n");
 				break;
 			}
 			rdstart[j] = dev5_mmio_hwport->m_dev5_reg_018;
@@ -4325,52 +5278,180 @@ static int cdvdman_send_scmd2(int cmd, const void *sdata, int sdlen, void *rdata
 		{
 			break;
 		}
-		VERBOSE_KPRINTF(1, "Prev Cmd Result Illegal Size Try count:%d\n", i);
+		VERBOSE_KPRINTF(1, "Prev Cmd2 Result Illegal Size Try count:%d\n", i);
 		while ( !(dev5_mmio_hwport->m_dev5_reg_017 & 0x20) )
 		{
 			;
 		}
 		for ( j = 0; j < 16 - rdlen; j += 1 )
-			;
+		{
+		}
 	}
 	if ( i == 1 )
 	{
+		if ( atapi_check )
+		{
+			set_cdvd_dev5_base_addr_atapi(1);
+		}
+		CpuResumeIntr(state);
 		if ( check_sef == 1 )
 		{
-			vSetEventFlag(g_scmd_evid, 1);
+			vSetEventFlag(g_scmd_evfid, 1);
 		}
 		return 0;
 	}
-	for ( i = 0; i < rdlen; i += 1 )
+	for ( j = 0; j < rdlen; j += 1 )
 	{
-		((char *)rdata)[i] = rdstart[i];
+		rdata[j] = rdstart[j];
 	}
+	if ( atapi_check )
+	{
+		set_cdvd_dev5_base_addr_atapi(1);
+	}
+	CpuResumeIntr(state);
 	if ( check_sef == 1 )
 	{
-		vSetEventFlag(g_scmd_evid, 1);
+		vSetEventFlag(g_scmd_evfid, 1);
 	}
 	return 1;
 }
+#endif
 
-int sceCdApplySCmd(u8 cmdNum, const void *inBuff, u16 inBuffSize, void *outBuff)
+static int cdvdman_send_scmd2(int cmd, const void *sdata, int sdlen, void *rdata, int rdlen, int check_sef)
 {
 	int i;
+	int j;
+	char rdstart[64];
+	u32 efbits;
+	USE_DEV5_MMIO_HWPORT();
 
-	for ( i = 0; i <= 2500; i += 1 )
+	if ( check_sef == 1 && vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
-		if ( set_prev_command(cmdNum, (const char *)inBuff, inBuffSize, (char *)outBuff, 16, 1) )
-		{
-			DelayThread(2000);
-			return 1;
-		}
-		DelayThread(2000);
+		return 0;
 	}
-	KPRINTF("CDVD: set_prev_command TIMEOUT 5(SEC)\n");
-	return 0;
-}
+	for ( i = 0; i <= 0; i += 1 )
+	{
+		int cmdresoverflow;
+
+		if ( (dev5_mmio_hwport->m_dev5_reg_017 & 0x80) )
+		{
+			if ( check_sef == 1 )
+			{
+				vSetEventFlag(g_scmd_evfid, 1);
+			}
+			return 0;
+		}
+		while ( !(dev5_mmio_hwport->m_dev5_reg_017 & 0x40) )
+		{
+			;
+		}
+		for ( j = 0; j < sdlen; j += 1 )
+		{
+			dev5_mmio_hwport->m_dev5_reg_017 = ((u8 *)sdata)[j];
+		}
+		dev5_mmio_hwport->m_dev5_reg_016 = cmd;
+		while ( (dev5_mmio_hwport->m_dev5_reg_017 & 0x80) )
+		{
+#ifndef CDVD_VARIANT_XOSD
+			DelayThread(100);
+#endif
+		}
+		cmdresoverflow = 0;
+		for ( j = 0; !(dev5_mmio_hwport->m_dev5_reg_017 & 0x40); j += 1 )
+		{
+			if ( j >= rdlen )
+			{
+				cmdresoverflow = 1;
+				// The following Kprintf was modified for ioprp300x
+				VERBOSE_KPRINTF(1, "Prev Cmd2 Result Over Flow\n");
+				break;
+			}
+			rdstart[j] = dev5_mmio_hwport->m_dev5_reg_018;
+		}
+		if ( (!cmdresoverflow && j >= rdlen) || rdlen == 16 )
+		{
+			break;
+		}
+		// The following Kprintf was modified for ioprp300x
+		VERBOSE_KPRINTF(1, "Prev Cmd2 Result Illegal Size Try count:%d\n", i);
+		while ( !(dev5_mmio_hwport->m_dev5_reg_017 & 0x20) )
+		{
+			;
+		}
+		for ( j = 0; j < 16 - rdlen; j += 1 )
+			;
+	}
+	if ( i == 1 )
+	{
+		if ( check_sef == 1 )
+		{
+			vSetEventFlag(g_scmd_evfid, 1);
+		}
+		return 0;
+	}
+	for ( i = 0; i < rdlen; i += 1 )
+	{
+		((char *)rdata)[i] = rdstart[i];
+	}
+	if ( check_sef == 1 )
+	{
+		vSetEventFlag(g_scmd_evfid, 1);
+	}
+	return 1;
+}
+
+#ifdef CDVD_VARIANT_OSD
+static unsigned int signal_sema_timeout_callback(void *userdata)
+{
+	int sema_id;
+
+	sema_id = (int)(u32)(uiptr)userdata;
+	iSignalSema(sema_id);
+	return 0;
+}
+#endif
+
+int sceCdApplySCmd(u8 cmdNum, const void *inBuff, u16 inBuffSize, void *outBuff)
+{
+	int i;
+
+#ifdef CDVD_VARIANT_OSD
+	if ( g_cdvdman_minver_50000 )
+	{
+		WaitSema(g_cdvdman_apply_scmd_sema);
+	}
+#endif
+	for ( i = 0; i <= 2500; i += 1 )
+	{
+		if ( set_prev_command(cmdNum, (const char *)inBuff, inBuffSize, (char *)outBuff, 16, 1) )
+		{
+#ifdef CDVD_VARIANT_OSD
+			if ( g_cdvdman_minver_50000 )
+			{
+				iop_sys_clock_t sysclk;
+
+				sysclk.hi = 0;
+				sysclk.lo = 0x9000;
+				SetAlarm(&sysclk, signal_sema_timeout_callback, (void *)g_cdvdman_apply_scmd_sema);
+			}
+			else
+#endif
+			{
+				DelayThread(2000);
+			}
+			return 1;
+		}
+		DelayThread(2000);
+	}
+	KPRINTF("CDVD: set_prev_command TIMEOUT 5(SEC)\n");
+	return 0;
+}
 
 int sceCdApplySCmd2(u8 cmdNum, const void *inBuff, unsigned long int inBuffSize, void *outBuff)
 {
+#ifdef CDVD_VARIANT_XOSD
+	return sceCdApplySCmd(cmdNum, inBuff, inBuffSize, outBuff);
+#else
 	int i;
 
 	for ( i = 0; i <= 2500; i += 1 )
@@ -4383,9 +5464,10 @@ int sceCdApplySCmd2(u8 cmdNum, const void *inBuff, unsigned long int inBuffSize,
 	}
 	KPRINTF("CDVD: set_prev_command TIMEOUT 5(SEC)\n");
 	return 0;
+#endif
 }
 
-#ifdef DEAD_CODE
+#ifdef CDVD_VARIANT_OSD
 int sceCdApplySCmd3(u8 cmdNum, const void *inBuff, unsigned long int inBuffSize, void *outBuff)
 {
 	int i;
@@ -4411,19 +5493,27 @@ int sceCdBreak(void)
 	int oldstate;
 	USE_DEV5_MMIO_HWPORT();
 
-	if ( PollEventFlag(g_ncmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( PollEventFlag(g_ncmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
 	CpuSuspendIntr(&state);
+	// The following Kprintf was modified for ioprp300x
 	VERBOSE_KPRINTF(
 		1,
-		"Break call: read2_flg= %d func= %d lsn= %d csec= %d nsec= %d\n",
+		"Break call: read2_flg= %d func= %d lsn= %d csec= %d nsec= %d %rsec= %d addr= %p waitflg= %d, DriveIntrReq= %d "
+		"stmflg= %d recover= %d\n",
 		g_cdvdman_istruct.m_read2_flag,
 		g_cdvdman_cmdfunc,
 		g_cdvdman_istruct.m_cdvdman_lsn,
 		g_cdvdman_istruct.m_cdvdman_csec,
-		g_cdvdman_istruct.m_cdvdman_nsec);
+		g_cdvdman_istruct.m_cdvdman_nsec,
+		g_cdvdman_istruct.m_cdvdman_rsec,
+		g_cdvdman_istruct.m_read_buf,
+		g_cdvdman_istruct.m_wait_flag,
+		g_cdvdman_istruct.m_drive_interupt_request,
+		g_cdvdman_istruct.m_stream_flag,
+		g_cdvdman_istruct.m_recover_status);
 	if ( g_cdvdman_istruct.m_last_read_timeout )
 	{
 		g_cdvdman_istruct.m_read2_flag = 0;
@@ -4441,17 +5531,18 @@ int sceCdBreak(void)
 	g_cdvdman_istruct.m_recover_status = 0;
 	if ( QueryIntrContext() )
 	{
-		iSetEventFlag(g_cdvdman_intr_efid, 0x29);
-		iCancelAlarm((unsigned int (*)(void *))read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
+		iSetEventFlag(g_cdvdman_intr_evfid, 0x29);
+		iCancelAlarm(read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
 	}
 	else
 	{
-		SetEventFlag(g_cdvdman_intr_efid, 0x29);
-		CancelAlarm((unsigned int (*)(void *))read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
+		SetEventFlag(g_cdvdman_intr_evfid, 0x29);
+		CancelAlarm(read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
 	}
 	if ( !g_cdvdman_istruct.m_wait_flag || g_cdvdman_istruct.m_last_read_timeout )
 	{
-		if ( (dev5_mmio_hwport->m_dev5_reg_005 & 0xC0) == 0x40 )
+		// The following direct register access was replaced with call for ioprp300x
+		if ( (sceCdDiskReady(8) & 0xC0) == 0x40 )
 		{
 			VERBOSE_KPRINTF(1, "cdvd: NonInter END\n");
 			g_cdvdman_istruct.m_wait_flag = 1;
@@ -4466,24 +5557,38 @@ int sceCdBreak(void)
 		g_cdvdman_istruct.m_drive_interupt_request = 0;
 		VERBOSE_KPRINTF(1, "cdvd: Abort command On\n");
 	}
-	vSetEventFlag(g_ncmd_evid, 1);
+	vSetEventFlag(g_ncmd_evfid, 1);
 	CpuResumeIntr(state);
 	return 1;
 }
 
-static int ncmd_timeout_alarm_cb(iop_sys_clock_t *sys_clock)
+static unsigned int ncmd_timeout_alarm_cb(void *userdata)
 {
+	iop_sys_clock_t *sys_clock;
+
+	sys_clock = (iop_sys_clock_t *)userdata;
 	KPRINTF("Cmd Time Out %d(msec)\n", sys_clock->lo / 0x9000);
 	sys_clock->lo = 0;
 	return 0;
 }
 
-static int intrh_dma_3(cdvdman_internal_struct_t *s)
+static int intrh_dma_3(void *userdata)
 {
 	int dmacbres;
 	int oldstate;
+	cdvdman_internal_struct_t *s;
 
+	s = (cdvdman_internal_struct_t *)userdata;
 	s->m_dma3_param.m_dma3_msectors -= s->m_dma3_param.m_dma3_csectors;
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(
+		1,
+		"_sceCdDmaIntr wk %d: func_num: %d nsec %d cnt %d cdid:%08x\n",
+		s->m_wait_flag,
+		g_cdvdman_cmdfunc,
+		s->m_dma3_param.m_dma3_msectors,
+		s->m_cdvdman_dma3sec,
+		&g_cdvdman_istruct);
 	dmacbres = s->m_dma3_param.m_dma3_callback ? s->m_dma3_param.m_dma3_callback() : 1;
 	s->m_cdvdman_dma3sec += s->m_dma3_param.m_dma3_csectors;
 	s->m_dma3_param.m_dma3_csectors = ((u32)s->m_read_chunk > (u32)s->m_dma3_param.m_dma3_msectors) ?
@@ -4501,12 +5606,12 @@ static int intrh_dma_3(cdvdman_internal_struct_t *s)
 				((s->m_dma3_param.m_dma3_blkcount * s->m_dma3_param.m_dma3_csectors) << 16) | s->m_dma3_param.m_dma3_blkwords);
 			dmac_ch_set_chcr(3, 0x41000200);
 			dmac_ch_get_chcr(3);
-			iClearEventFlag(g_cdvdman_intr_efid, ~0x20);
+			iClearEventFlag(g_cdvdman_intr_evfid, ~0x20);
 		}
 		else
 		{
 			DisableIntr(IOP_IRQ_DMA_CDVD, &oldstate);
-			iSetEventFlag(g_cdvdman_intr_efid, 0x20);
+			iSetEventFlag(g_cdvdman_intr_evfid, 0x20);
 		}
 	}
 	if ( !s->m_dma3_param.m_dma3_msectors && s->m_drive_interupt_request )
@@ -4538,7 +5643,7 @@ static int cdvdman_setdma3(cdvdman_dma3_parameter_t *dma3_param)
 	dmac_ch_get_chcr(3);
 	if ( dma3_param->m_dma3_csectors )
 	{
-		vClearEventFlag(g_cdvdman_intr_efid, ~0x20);
+		vClearEventFlag(g_cdvdman_intr_evfid, ~0x20);
 		EnableIntr(IOP_IRQ_DMA_CDVD);
 	}
 	dev5_mmio_hwport->m_dev5_reg_006 = dma3_param->m_cdvdreg_howto;
@@ -4551,6 +5656,346 @@ static int cdvdman_setdma3(cdvdman_dma3_parameter_t *dma3_param)
 	return dmac_ch_get_chcr(3);
 }
 
+#ifdef CDVD_VARIANT_XOSD
+static int update_cd_mode_ps2_atapi(void)
+{
+	int is_intr_context;
+	int saved_cd_mode_ps2_atapi;
+	int state;
+
+	is_intr_context = !QueryIntrContext();
+	if ( is_intr_context )
+	{
+		CpuSuspendIntr(&state);
+	}
+	saved_cd_mode_ps2_atapi = g_cdvdman_istruct.m_cd_mode_ps2_atapi;
+	if ( saved_cd_mode_ps2_atapi == 1 )
+	{
+		if ( !(*g_cdvdreg_bf801460 & 2) || (unsigned int)GetBaseAddress(5) != (unsigned int)0xBF410000 )
+		{
+			set_cdvd_dev5_base_addr_atapi(1);
+		}
+	}
+	else
+	{
+		if ( (*g_cdvdreg_bf801460 & 2) || (unsigned int)GetBaseAddress(5) != (unsigned int)0x1F402000 )
+		{
+			set_cdvd_dev5_base_addr_atapi(2);
+		}
+	}
+	if ( is_intr_context )
+	{
+		CpuResumeIntr(state);
+	}
+	return saved_cd_mode_ps2_atapi;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static int set_cdvd_dev5_base_addr_atapi(int mode)
+{
+	int is_intr_context;
+	int state;
+
+	is_intr_context = !QueryIntrContext();
+	if ( is_intr_context )
+	{
+		CpuSuspendIntr(&state);
+	}
+	if ( mode == 1 )
+	{
+		SetBaseAddress(5, 0xBF410000);
+		VERBOSE_KPRINTF(1, "DEV5-addr : 0x%08lx\n", GetBaseAddress(5));
+		SetDelay(5, 0xEF101043);
+		VERBOSE_KPRINTF(1, "DEV5-dely : 0x%08lx\n", GetDelay(5));
+		*g_cdvdreg_bf801464 |= 0xC;
+		*g_cdvdreg_bf801460 |= 0x40;
+		*g_cdvdreg_bf801460 |= 2;
+	}
+	else
+	{
+		SetBaseAddress(5, 0x1F402000);
+		VERBOSE_KPRINTF(1, "DEV5-addr : 0x%08lx\n", GetBaseAddress(5));
+		SetDelay(5, 0x6F060011);
+		VERBOSE_KPRINTF(1, "DEV5-dely : 0x%08lx\n", GetDelay(5));
+		*g_cdvdreg_bf801460 &= ~2;
+		*g_cdvdreg_bf801460 &= ~0x40;
+		*g_cdvdreg_bf801464 &= 0xF3;
+	}
+	if ( is_intr_context )
+	{
+		CpuResumeIntr(state);
+	}
+	return 1;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static int cdvdman_change_drive(int mode)
+{
+	ClearEventFlag(g_cdvdman_csys_evfid, ~1);
+	if ( mode == 1 )
+	{
+		VERBOSE_KPRINTF(1, "Init Go SCECdChgWriDrv\n");
+		ClearEventFlag(g_fio_fsv_evfid, ~1);
+		ClearEventFlag(g_sfile_evfid, ~1);
+		ClearEventFlag(g_scmd_evfid, ~1);
+		ClearEventFlag(g_ncmd_evfid, ~1);
+		set_cdvd_dev5_base_addr_atapi(1);
+		if ( g_cd_atapi_evfid != -1 )
+		{
+			SetEventFlag(g_cd_atapi_evfid, 3);
+		}
+		if ( g_adma_evfid != -1 )
+		{
+			SetEventFlag(g_adma_evfid, 1);
+		}
+		if ( g_acmd_evfid != -1 )
+		{
+			SetEventFlag(g_acmd_evfid, 1);
+		}
+		SetEventFlag(g_scmd_evfid, 1);
+		VERBOSE_KPRINTF(1, "Init Go SCECdChgWriDrv End.\n");
+		SetEventFlag(g_fio_fsv_evfid, 1);
+	}
+	else
+	{
+		VERBOSE_KPRINTF(1, "Init Go SCECdChgPs2Drv\n");
+		ClearEventFlag(g_scmd_evfid, ~1);
+		if ( g_acmd_evfid != -1 )
+		{
+			ClearEventFlag(g_acmd_evfid, ~1);
+		}
+		if ( g_adma_evfid != -1 )
+		{
+			ClearEventFlag(g_adma_evfid, ~1);
+		}
+		if ( g_cd_atapi_evfid != -1 )
+		{
+			ClearEventFlag(g_cd_atapi_evfid, ~3);
+		}
+		set_cdvd_dev5_base_addr_atapi(mode);
+		SetEventFlag(g_ncmd_evfid, 1);
+		SetEventFlag(g_scmd_evfid, 1);
+		SetEventFlag(g_sfile_evfid, 1);
+		SetEventFlag(g_fio_fsv_evfid, 1);
+		VERBOSE_KPRINTF(1, "Init Go SCECdChgPs2Drv End.\n");
+	}
+	SetEventFlag(g_cdvdman_csys_evfid, 1);
+	return 1;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdChgSys(u32 use_writer_drive)
+{
+	int current_mode;
+	u32 efbits;
+	USE_DEV5_MMIO_HWPORT();
+
+	VERBOSE_KPRINTF(1, "sceCdChgSys(%d) start.\n", use_writer_drive);
+	if ( QueryIntrContext() )
+	{
+		return 0;
+	}
+	WaitEventFlag(g_cdvdman_csys_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+	current_mode = update_cd_mode_ps2_atapi();
+	VERBOSE_KPRINTF(
+		1, "sceCdChgSys %d call mode:%d->%d\n", use_writer_drive, current_mode, g_cdvdman_istruct.m_cd_mode_ps2_atapi);
+	if ( !use_writer_drive )
+	{
+		g_cdvdman_istruct.m_cd_mode_ps2_atapi = current_mode;
+	}
+	if (
+		use_writer_drive
+		&& (use_writer_drive != (u32)current_mode || g_cdvdman_istruct.m_cd_mode_ps2_atapi != current_mode) )
+	{
+		int disc_type;
+
+		if ( use_writer_drive == 1 )
+		{
+			VERBOSE_KPRINTF(1, "Go SCECdChgWriDrv\n");
+			VERBOSE_KPRINTF(1, "fio_fsv_evfid\n");
+			WaitEventFlag(g_fio_fsv_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			VERBOSE_KPRINTF(1, "sfile_evfid\n");
+			WaitEventFlag(g_sfile_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			VERBOSE_KPRINTF(1, "sceCdSync\n");
+			sceCdSync(0);
+			VERBOSE_KPRINTF(1, "scmd_evfid\n");
+			WaitEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			VERBOSE_KPRINTF(1, "ncmd_evfid\n");
+			WaitEventFlag(g_ncmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			set_cdvd_dev5_base_addr_atapi(2);
+			disc_type = dev5_mmio_hwport->m_dev5_reg_00F;
+			if ( g_cdvdman_vernotxxx1x )
+			{
+				if ( (dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen) )
+				{
+					g_cdvdman_istruct.m_chgsys_writer_drive_shell_is_open = 1;
+				}
+				if (
+					(!(dev5_mmio_hwport->m_dev5_reg_015 & 0x80) && !(dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen))
+					|| (dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen) )
+				{
+					int last_err;
+
+					last_err = 2;
+					while ( last_err != SCECdErNO && last_err != SCECdErABRT )
+					{
+						VERBOSE_KPRINTF(1, "GO->Atapi sceCdChgSpdlCtrl Call %d\n", 0);
+						while ( !sceCdChgSpdlCtrl(0) )
+						{
+							DelayThread(16000);
+						}
+						sceCdSync(3);
+						last_err = sceCdGetError();
+						if ( last_err != SCECdErNO )
+						{
+							VERBOSE_KPRINTF(1, "** sceCdChgSpdlCtrl ERR 0x%02x\n", last_err);
+							DelayThread(250000);
+						}
+					}
+					VERBOSE_KPRINTF(1, "** sceCdChgSpdlCtrl OK\n", last_err);
+				}
+			}
+			set_cdvd_dev5_base_addr_atapi(1);
+			g_cdvdman_istruct.m_cd_mode_ps2_atapi = 1;
+			if (
+				g_cdvdman_vernotxxx1x && disc_type != SCECdNODISC && g_cdvdman_istruct.m_chgsys_callback_next_disktype_last
+				&& g_cdvdman_istruct.m_chgsys_callback )
+			{
+				int i;
+
+				for ( i = 0;
+							i < 10 && g_cdvdman_istruct.m_chgsys_callback(&g_cdvdman_istruct.m_chgsys_callback_next_disktype, 1);
+							i += 1 )
+				{
+					DelayThread(16000);
+				}
+				g_cdvdman_istruct.m_chgsys_callback_next_disktype_last = SCECdNODISC;
+			}
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				SetEventFlag(g_cd_atapi_evfid, 3);
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				SetEventFlag(g_adma_evfid, 1);
+			}
+			if ( g_acmd_evfid != -1 )
+			{
+				SetEventFlag(g_acmd_evfid, 1);
+			}
+			SetEventFlag(g_scmd_evfid, 1);
+			SetEventFlag(g_fio_fsv_evfid, 1);
+			VERBOSE_KPRINTF(1, "Go SCECdChgWriDrv End.\n");
+		}
+		else
+		{
+			VERBOSE_KPRINTF(1, "Go SCECdChgPs2Drv\n");
+			VERBOSE_KPRINTF(1, "scmd_evfid\n");
+			WaitEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			if ( g_acmd_evfid != -1 )
+			{
+				VERBOSE_KPRINTF(1, "g_acmd_evfid Wait\n");
+				WaitEventFlag(g_acmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			if ( g_adma_evfid != -1 )
+			{
+				VERBOSE_KPRINTF(1, "g_adma_evfid Wait\n");
+				WaitEventFlag(g_adma_evfid, 1, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			if ( g_cd_atapi_evfid != -1 )
+			{
+				VERBOSE_KPRINTF(1, "g_cd_atapi_evfid Wait\n");
+				WaitEventFlag(g_cd_atapi_evfid, 3, WEF_AND | WEF_CLEAR, &efbits);
+			}
+			VERBOSE_KPRINTF(1, "evflg Ok\n");
+			set_cdvd_dev5_base_addr_atapi(1);
+			g_cdvdman_istruct.m_chgsys_callback_next_disktype = SCECdDETCTDVDD;
+			if ( g_cdvdman_vernotxxx1x )
+			{
+				set_cdvd_dev5_base_addr_atapi(2);
+				disc_type = dev5_mmio_hwport->m_dev5_reg_00F;
+				set_cdvd_dev5_base_addr_atapi(1);
+				VERBOSE_KPRINTF(1, "GO->PS2 STOP ATAPI SPINDL\n");
+				if ( disc_type == 6 && g_cdvdman_istruct.m_chgsys_callback )
+				{
+					int i;
+
+					for ( i = 0;
+								i < 10 && g_cdvdman_istruct.m_chgsys_callback(&g_cdvdman_istruct.m_chgsys_callback_next_disktype, 0);
+								i += 1 )
+					{
+						DelayThread(16000);
+					}
+					if ( i == 10 )
+					{
+						g_cdvdman_istruct.m_chgsys_callback_next_disktype = SCECdDETCTDVDD;
+					}
+					VERBOSE_KPRINTF(1, "Atapi Set -> Dragon Media %d\n", g_cdvdman_istruct.m_chgsys_callback_next_disktype);
+					if ( g_cdvdman_istruct.m_chgsys_callback_next_disktype == 256 )
+					{
+						g_cdvdman_istruct.m_chgsys_callback_next_disktype_last = g_cdvdman_istruct.m_chgsys_callback_next_disktype;
+						g_cdvdman_istruct.m_chgsys_callback_next_disktype = SCECdDETCTDVDD;
+					}
+				}
+			}
+			set_cdvd_dev5_base_addr_atapi(use_writer_drive);
+			g_cdvdman_istruct.m_cd_mode_ps2_atapi = use_writer_drive;
+			disc_type = dev5_mmio_hwport->m_dev5_reg_00F;
+			if ( g_cdvdman_vernotxxx1x )
+			{
+				if (
+					((dev5_mmio_hwport->m_dev5_reg_015 & 0x80) && !(dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen))
+					|| (dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen) )
+				{
+					int last_err;
+
+					last_err = 2;
+					while ( last_err != SCECdErNO && last_err != SCECdErABRT && last_err != SCECdErPRM )
+					{
+						if ( (dev5_mmio_hwport->m_dev5_reg_00A & SCECdStatShellOpen) )
+						{
+							g_cdvdman_istruct.m_chgsys_callback_next_disktype = SCECdDETCT;
+						}
+						VERBOSE_KPRINTF(
+							1,
+							"GO->DRAGON sceCdChgSpdlCtrl Call %d Ps2MediaType %02x\n",
+							g_cdvdman_istruct.m_chgsys_callback_next_disktype,
+							disc_type);
+						while ( !sceCdChgSpdlCtrl(g_cdvdman_istruct.m_chgsys_callback_next_disktype) )
+						{
+							DelayThread(16000);
+						}
+						sceCdSync(3);
+						last_err = sceCdGetError();
+						if ( last_err != SCECdErNO )
+						{
+							VERBOSE_KPRINTF(1, "** sceCdChgSpdlCtrl ERR 0x%02x\n", last_err);
+							DelayThread(250000);
+						}
+					}
+					VERBOSE_KPRINTF(1, "** sceCdChgSpdlCtrl OK\n");
+				}
+			}
+			else
+			{
+				VERBOSE_KPRINTF(1, " -> Ps2 May be No media %08x\n", disc_type);
+			}
+			SetEventFlag(g_ncmd_evfid, 1);
+			SetEventFlag(g_scmd_evfid, 1);
+			SetEventFlag(g_sfile_evfid, 1);
+			SetEventFlag(g_fio_fsv_evfid, 1);
+			VERBOSE_KPRINTF(1, "Go SCECdChgPs2Drv End.\n");
+		}
+	}
+	SetEventFlag(g_cdvdman_csys_evfid, 1);
+	return current_mode;
+}
+#endif
+
 static int
 cdvdman_send_ncmd(int ncmd, const void *ndata, int ndlen, int func, cdvdman_dma3_parameter_t *dma3_param, int check_cb)
 {
@@ -4558,19 +6003,21 @@ cdvdman_send_ncmd(int ncmd, const void *ndata, int ndlen, int func, cdvdman_dma3
 	u32 efbits;
 	USE_DEV5_MMIO_HWPORT();
 
-	if ( check_cb == 1 && PollEventFlag(g_ncmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( check_cb == 1 && PollEventFlag(g_ncmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return -1;
 	}
 	if (
-		(dev5_mmio_hwport->m_dev5_reg_005 & 0xC0) != 0x40 || !g_cdvdman_istruct.m_wait_flag
+		// The following direct register access was replaced with call for ioprp300x
+		(sceCdDiskReady(8) & 0xC0) != 0x40 || !g_cdvdman_istruct.m_wait_flag
 		|| !(g_cdvdman_istruct.m_read2_flag != 1 || ncmd == 8) || !(g_cdvdman_istruct.m_read2_flag != 2 || ncmd == 6) )
 	{
 		if ( check_cb == 1 )
 		{
-			vSetEventFlag(g_ncmd_evid, 1);
+			vSetEventFlag(g_ncmd_evfid, 1);
 		}
-		VERBOSE_KPRINTF(1, "set_cd_commnad Error\tstat %02x\n", (u8)dev5_mmio_hwport->m_dev5_reg_005);
+		// The following direct register access was replaced with call for ioprp300x
+		VERBOSE_KPRINTF(1, "set_cd_commnad Error\tstat %02x\n", (u8)sceCdDiskReady(8));
 		return -1;
 	}
 	g_cdvdman_iocache = 0;
@@ -4581,13 +6028,17 @@ cdvdman_send_ncmd(int ncmd, const void *ndata, int ndlen, int func, cdvdman_dma3
 	g_cdvdman_cmdfunc = func;
 	// The following call to sceCdGetDiskType was inlined
 	if (
-		!g_cdvdman_minver_10700 && g_cdvdman_ncmd == 6 && ncmd && ncmd != g_cdvdman_ncmd && ncmd != 7 && ncmd != 14
-		&& ncmd != 8 && (sceCdGetDiskType() != SCECdCDDA || ncmd == 3) )
+		!g_cdvdman_minver_10700 && g_cdvdman_ncmd == 0x06 && ncmd && ncmd != g_cdvdman_ncmd && ncmd != 0x07 && ncmd != 0x0E
+		&& ncmd != 0x08
+#ifdef CDVD_VARIANT_XOSD
+		&& ncmd != 0x0C
+#endif
+		&& (sceCdGetDiskType() != SCECdCDDA || ncmd == 0x03) )
 	{
 		g_cdvdman_ncmd_timeout.hi = 0;
 		g_cdvdman_ncmd_timeout.lo = 0x6978000;
-		vSetAlarm(&g_cdvdman_ncmd_timeout, (unsigned int (*)(void *))ncmd_timeout_alarm_cb, &g_cdvdman_ncmd_timeout);
-		while ( dev5_mmio_hwport->m_dev5_reg_00A != 10 )
+		vSetAlarm(&g_cdvdman_ncmd_timeout, ncmd_timeout_alarm_cb, &g_cdvdman_ncmd_timeout);
+		while ( dev5_mmio_hwport->m_dev5_reg_00A != SCECdStatPause )
 		{
 			VERBOSE_KPRINTF(1, "Read Pause 1 chk status 0x%02x\n", dev5_mmio_hwport->m_dev5_reg_00A);
 			if ( !g_cdvdman_ncmd_timeout.lo )
@@ -4595,14 +6046,14 @@ cdvdman_send_ncmd(int ncmd, const void *ndata, int ndlen, int func, cdvdman_dma3
 				g_cdvdman_ncmd = ncmd;
 				if ( check_cb == 1 )
 				{
-					vSetEventFlag(g_ncmd_evid, 1);
+					vSetEventFlag(g_ncmd_evfid, 1);
 				}
 				KPRINTF("Time Out Pause WAIT set_cd_commnad\n");
 				return -1;
 			}
 			vDelayThread(1000);
 		}
-		vCancelAlarm((unsigned int (*)(void *))ncmd_timeout_alarm_cb, &g_cdvdman_ncmd_timeout);
+		vCancelAlarm(ncmd_timeout_alarm_cb, &g_cdvdman_ncmd_timeout);
 	}
 	g_cdvdman_ncmd = ncmd;
 	if ( g_cdvdman_istruct.m_dec_state )
@@ -4611,16 +6062,16 @@ cdvdman_send_ncmd(int ncmd, const void *ndata, int ndlen, int func, cdvdman_dma3
 	}
 	g_cdvdman_istruct.m_last_read_timeout = 0;
 	g_cdvdman_istruct.m_cdvdman_command = ncmd;
-	g_cdvdman_istruct.m_last_error = 0;
+	g_cdvdman_istruct.m_last_error = SCECdErNO;
 	g_cdvdman_istruct.m_wait_flag = 0;
 	g_cdvdman_istruct.m_thread_id = GetThreadId();
 	if ( QueryIntrContext() )
 	{
-		iClearEventFlag(g_cdvdman_intr_efid, ~1);
+		iClearEventFlag(g_cdvdman_intr_evfid, ~1);
 	}
 	else
 	{
-		ClearEventFlag(g_cdvdman_intr_efid, ~1);
+		ClearEventFlag(g_cdvdman_intr_evfid, ~1);
 	}
 	for ( i = 0; i < ndlen; i += 1 )
 	{
@@ -4629,7 +6080,7 @@ cdvdman_send_ncmd(int ncmd, const void *ndata, int ndlen, int func, cdvdman_dma3
 	dev5_mmio_hwport->m_dev5_reg_004 = ncmd;
 	if ( check_cb == 1 )
 	{
-		vSetEventFlag(g_ncmd_evid, 1);
+		vSetEventFlag(g_ncmd_evfid, 1);
 	}
 	return 0;
 }
@@ -4653,24 +6104,30 @@ int sceCdCheckCmd(void)
 static int cdvdman_mediactl(int code)
 {
 	int reg_00B_tmp_1;
-	int restmp;
+	int retval;
 	u32 efbits;
-	int rdata;
+	char rdata[1];
+#ifndef CDVD_VARIANT_XOSD
 	USE_DEV5_MMIO_HWPORT();
+#endif
 
-	rdata = 0;
-	if ( PollEventFlag(g_scmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	rdata[0] = 0;
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
-	reg_00B_tmp_1 = dev5_mmio_hwport->m_dev5_reg_00B & 1;
+#ifdef CDVD_VARIANT_XOSD
+	reg_00B_tmp_1 = get_cdvd_register(0x0B) & SCECdStatShellOpen;
+#else
+	reg_00B_tmp_1 = dev5_mmio_hwport->m_dev5_reg_00B & SCECdStatShellOpen;
+#endif
 	if ( reg_00B_tmp_1 == g_cdvdman_chmedia )
 	{
-		restmp = 0;
+		retval = 0;
 		if ( g_cdvdman_chflags[code] )
 		{
 			g_cdvdman_chflags[code] = 0;
-			restmp = 1;
+			retval = 1;
 		}
 	}
 	else
@@ -4681,23 +6138,31 @@ static int cdvdman_mediactl(int code)
 		{
 			g_cdvdman_chflags[i] = i != (unsigned int)code;
 		}
-		restmp = 1;
+		retval = 1;
 	}
-	if ( ((dev5_mmio_hwport->m_dev5_reg_00A) & 1) != reg_00B_tmp_1 )
+#ifdef CDVD_VARIANT_XOSD
+	if ( ((get_cdvd_register(0x0A)) & SCECdStatShellOpen) != reg_00B_tmp_1 )
+#else
+	if ( ((dev5_mmio_hwport->m_dev5_reg_00A) & SCECdStatShellOpen) != reg_00B_tmp_1 )
+#endif
 	{
-		while ( !set_prev_command(5, 0, 0, (char *)&rdata, 1, 0) || rdata )
+		while ( !set_prev_command(0x05, NULL, 0, rdata, sizeof(rdata), 0) || rdata[0] )
 		{
 			vDelayThread(4000);
 		}
 	}
-	g_cdvdman_chmedia = dev5_mmio_hwport->m_dev5_reg_00B & 1;
-	vSetEventFlag(g_scmd_evid, 1);
-	return restmp;
-}
-
+#ifdef CDVD_VARIANT_XOSD
+	g_cdvdman_chmedia = get_cdvd_register(0x0B) & 1;
+#else
+	g_cdvdman_chmedia = dev5_mmio_hwport->m_dev5_reg_00B & SCECdStatShellOpen;
+#endif
+	vSetEventFlag(g_scmd_evfid, 1);
+	return retval;
+}
+
 int sceCdGetError(void)
 {
-	if ( g_cdvdman_istruct.m_last_error )
+	if ( g_cdvdman_istruct.m_last_error != SCECdErNO )
 	{
 		VERBOSE_KPRINTF(1, "sceCdGetError: 0x%02x\n", (u8)g_cdvdman_istruct.m_last_error);
 	}
@@ -4705,7 +6170,7 @@ int sceCdGetError(void)
 }
 
 #ifdef DEAD_CODE
-int cdvdman_get_last_command()
+int cdvdman_get_last_command(void)
 {
 	return (u8)g_cdvdman_istruct.m_cdvdman_command;
 }
@@ -4713,17 +6178,18 @@ int cdvdman_get_last_command()
 
 int sceCdNop(void)
 {
-	return cdvdman_send_ncmd(0, 0, 0, 0, 0, 1) >= 0;
+	return cdvdman_send_ncmd(0x00, NULL, 0, 0, 0, 1) >= 0;
 }
 
 #ifdef DEAD_CODE
-int cdvdman_ncmd_sender_01()
+int cdvdman_ncmd_sender_01(void)
 {
-	return cdvdman_send_ncmd(1, 0, 0, 0, 0, 1) >= 0;
+	return cdvdman_send_ncmd(0x01, NULL, 0, 0, 0, 1) >= 0;
 }
 #endif
 
-static int cdvdman_ncmd_sender_06()
+#ifndef CDVD_VARIANT_XOSD
+static int cdvdman_ncmd_sender_06(void)
 {
 	int i;
 	cdvdman_dma3_parameter_t dma3_param;
@@ -4736,6 +6202,7 @@ static int cdvdman_ncmd_sender_06()
 	}
 	for ( i = 0; i < 48; i += 8 )
 	{
+		// The following Kprintf was removed for ioprp300x
 		KPRINTF("CMD_READP call\n");
 		ndata[0] = i + 17;
 		ndata[3] = 0;
@@ -4755,7 +6222,7 @@ static int cdvdman_ncmd_sender_06()
 		dma3_param.m_dma3_msectors = 0;
 		dma3_param.m_dma3_callback = 0;
 		dma3_param.m_dma3_maddress = g_cdvdman_ptoc;
-		if ( cdvdman_send_ncmd(6, ndata, sizeof(ndata), 5, &dma3_param, 1) < 0 )
+		if ( cdvdman_send_ncmd(0x06, ndata, sizeof(ndata), 5, &dma3_param, 1) < 0 )
 		{
 			return 0;
 		}
@@ -4763,14 +6230,19 @@ static int cdvdman_ncmd_sender_06()
 	}
 	return 1;
 }
+#endif
 
 int sceCdStandby(void)
 {
 	cdvdman_dma3_parameter_t dma3_param;
 	char ndata[11];
 
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
 	// The following call to sceCdGetDiskType was inlined
 	switch ( sceCdGetDiskType() )
+#endif
 	{
 		case SCECdPSCD:
 		case SCECdPSCDDA:
@@ -4795,36 +6267,38 @@ int sceCdStandby(void)
 			dma3_param.m_dma3_msectors = 0;
 			dma3_param.m_dma3_callback = 0;
 			dma3_param.m_dma3_maddress = g_cdvdman_ptoc;
-			return cdvdman_send_ncmd(6, ndata, sizeof(ndata), 5, &dma3_param, 1) >= 0;
+			return cdvdman_send_ncmd(0x06, ndata, sizeof(ndata), 5, &dma3_param, 1) >= 0;
 		default:
-			return cdvdman_send_ncmd(2, 0, 0, 5, 0, 1) >= 0;
+			return cdvdman_send_ncmd(0x02, NULL, 0, 5, 0, 1) >= 0;
 	}
 }
 
 int sceCdStop(void)
 {
-	return cdvdman_send_ncmd(3, 0, 0, 6, 0, 1) >= 0;
+	return cdvdman_send_ncmd(0x03, NULL, 0, 6, 0, 1) >= 0;
 }
 
 int sceCdPause(void)
 {
-	return cdvdman_send_ncmd(4, 0, 0, 7, 0, 1) >= 0;
+	return cdvdman_send_ncmd(0x04, NULL, 0, 7, 0, 1) >= 0;
 }
 
 #ifdef DEAD_CODE
-int cdvdman_ncmd_sender_0B()
+int cdvdman_ncmd_sender_0B(void)
 {
-	char ndata;
+	char ndata[1];
 
-	ndata = 1;
-	return cdvdman_send_ncmd(11, &ndata, sizeof(ndata), 0, 0, 1) >= 0;
+	ndata[0] = 1;
+	return cdvdman_send_ncmd(0x0B, ndata, sizeof(ndata), 0, 0, 1) >= 0;
 }
 #endif
 
-static int readtoc_timeout_alarm_cb(iop_sys_clock_t *sys_clock)
+static unsigned int readtoc_timeout_alarm_cb(void *userdata)
 {
+	iop_sys_clock_t *sys_clock;
 	USE_DEV5_MMIO_HWPORT();
 
+	sys_clock = (iop_sys_clock_t *)userdata;
 	KPRINTF("Cmd Time Out %d(msec)\n", sys_clock->lo / 0x9000);
 	dev5_mmio_hwport->m_dev5_reg_007 = 1;
 	sys_clock->lo = 0;
@@ -4833,13 +6307,17 @@ static int readtoc_timeout_alarm_cb(iop_sys_clock_t *sys_clock)
 
 static int cdvdman_readtoc(u8 *toc, int param, int func)
 {
-	int errcond;
+	int last_err;
 	cdvdman_dma3_parameter_t dma3_param;
 	iop_sys_clock_t sysclk;
-	char ndata;
+	char ndata[1];
 
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
 	// The following call to sceCdGetDiskType was inlined
 	switch ( sceCdGetDiskType() )
+#endif
 	{
 		case SCECdPS2DVD:
 		case SCECdDVDVR:
@@ -4851,12 +6329,13 @@ static int cdvdman_readtoc(u8 *toc, int param, int func)
 			dma3_param.m_dma3_msectors = 0;
 			dma3_param.m_dma3_csectors = 0;
 			dma3_param.m_dma3_callback = 0;
-			ndata = param;
+			ndata[0] = param;
 			break;
 		case SCECdPSCD:
 		case SCECdPSCDDA:
 		case SCECdPS2CD:
 		case SCECdPS2CDDA:
+		case SCECdCDDA:
 			dma3_param.m_cdvdreg_howto = 128;
 			dma3_param.m_dma3_blkwords = 32;
 			dma3_param.m_dma3_blkcount = 8;
@@ -4864,36 +6343,54 @@ static int cdvdman_readtoc(u8 *toc, int param, int func)
 			dma3_param.m_dma3_msectors = 0;
 			dma3_param.m_dma3_csectors = 0;
 			dma3_param.m_dma3_callback = 0;
-			ndata = 0;
-			break;
-		case 0xFD:
+			ndata[0] = 0;
 			break;
 		default:
 			return 0;
 	}
-	if ( cdvdman_send_ncmd(9, &ndata, sizeof(ndata), func, &dma3_param, 1) < 0 )
+	if ( cdvdman_send_ncmd(0x09, ndata, sizeof(ndata), func, &dma3_param, 1) < 0 )
 	{
 		return 0;
 	}
 	sysclk.hi = 0;
 	sysclk.lo = 0x15F90000;
-	vSetAlarm(&sysclk, (unsigned int (*)(void *))readtoc_timeout_alarm_cb, &sysclk);
+	vSetAlarm(&sysclk, readtoc_timeout_alarm_cb, &sysclk);
 	sceCdSync(3);
-	vCancelAlarm((unsigned int (*)(void *))readtoc_timeout_alarm_cb, &sysclk);
-	errcond = !sceCdGetError();
+	vCancelAlarm(readtoc_timeout_alarm_cb, &sysclk);
+	last_err = sceCdGetError();
 	if ( g_cdvdman_minver_10700 && !sceCdPause() )
 	{
 		return 0;
 	}
 	sceCdSync(3);
-	return errcond;
+	return last_err == SCECdErNO;
 }
 
 static int cdvdman_gettoc(u8 *toc)
 {
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "sceCdReadToc() call 0x%p\n", toc);
 	return cdvdman_readtoc(toc, 0, 3);
 }
 
+#ifdef CDVD_VARIANT_OSD
+int sceCdGetToc2(u8 *toc, int param)
+{
+	cdvdman_dma3_parameter_t dma3_param;
+	char ndata[1];
+
+	dma3_param.m_cdvdreg_howto = 140;
+	dma3_param.m_dma3_blkwords = 12;
+	dma3_param.m_dma3_blkcount = 43;
+	dma3_param.m_dma3_maddress = toc;
+	dma3_param.m_dma3_msectors = 0;
+	dma3_param.m_dma3_csectors = 0;
+	dma3_param.m_dma3_callback = 0;
+	ndata[0] = param;
+	return cdvdman_send_ncmd(0x09, ndata, sizeof(ndata), 0, &dma3_param, 1) >= 0;
+}
+#endif
+
 u32 sceCdGetReadPos(void)
 {
 	int sector_sizes[4];
@@ -4937,11 +6434,21 @@ static int cdvdman_speedctl(u32 spindlctrl, int dvdflag, u32 maxlsn)
 			{
 				return 131;
 			}
+#ifdef CDVD_VARIANT_OSD
+			// From DVD Player 3.11
+			maxlsn_chk = 0x1C9000;
+#else
 			maxlsn_chk = 0x128000;
+#endif
 			if ( g_cdvdman_istruct.m_opo_or_para )
 			{
 				maxlsn -= (maxlsn >= (u32)g_cdvdman_istruct.m_layer_1_lsn) ? g_cdvdman_istruct.m_layer_1_lsn : 0;
+#ifdef CDVD_VARIANT_OSD
+				// From DVD Player 3.11
+				maxlsn_chk = 0x197000;
+#else
 				maxlsn_chk = 0x165000;
+#endif
 			}
 			if ( maxlsn >= maxlsn_chk )
 			{
@@ -4977,27 +6484,27 @@ static int cdvdman_speedctl(u32 spindlctrl, int dvdflag, u32 maxlsn)
 	}
 }
 
-static int cdvdman_isdvd()
+static int cdvdman_isdvd(void)
 {
 	// The following call to sceCdGetDiskType was inlined
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
 	switch ( sceCdGetDiskType() )
+#endif
 	{
 		case SCECdPSCD:
 		case SCECdPSCDDA:
 		case SCECdPS2CD:
 		case SCECdPS2CDDA:
+		case SCECdCDDA:
 			g_cdvdman_istruct.m_tray_is_open = 1;
 			return 0;
 		case SCECdPS2DVD:
-			g_cdvdman_istruct.m_tray_is_open = 1;
-			return 1;
 		case SCECdDVDVR:
 		case SCECdDVDV:
 			g_cdvdman_istruct.m_tray_is_open = 1;
 			return 1;
-		case SCECdCDDA:
-			g_cdvdman_istruct.m_tray_is_open = 1;
-			return 0;
 		default:
 			return 0;
 	}
@@ -5019,45 +6526,40 @@ static int sceCdRead0_Rty(u32 lsn, u32 nsec, void *buf, const sceCdRMode *mode,
 	dma3_param.m_dma3_msectors = nsec;
 	dma3_param.m_dma3_maddress = buf;
 	dma3_param.m_dma3_blkcount = (!(u16)dintrsec) ? nsec : 1;
-	if ( ncmd == 6 )
-	{
-		ndata[10] = mode->datapattern;
-		switch ( mode->datapattern )
-		{
-			case 1:
-				dma3_param.m_dma3_blkwords = 6;
-				dma3_param.m_dma3_blkcount *= 97;
-				dma3_param.m_cdvdreg_howto = 134;
-				break;
-			case 2:
-				dma3_param.m_dma3_blkwords = 15;
-				dma3_param.m_dma3_blkcount *= 39;
-				dma3_param.m_cdvdreg_howto = 143;
-				break;
-			case 0:
-			default:
-				dma3_param.m_dma3_blkwords = 32;
-				dma3_param.m_dma3_blkcount *= 16;
-				dma3_param.m_cdvdreg_howto = 128;
-				break;
-		}
-		if ( cdvdman_send_ncmd(ncmd, ndata, sizeof(ndata), 1, &dma3_param, 0) >= 0 )
-		{
-			return 1;
-		}
-	}
-	if ( ncmd == 8 )
+	switch ( ncmd )
 	{
-		dma3_param.m_dma3_blkwords = 12;
-		dma3_param.m_dma3_blkcount *= 43;
-		dma3_param.m_cdvdreg_howto = 140;
-		ndata[10] = 0;
-		if ( cdvdman_send_ncmd(ncmd, ndata, sizeof(ndata), 14, &dma3_param, 0) >= 0 )
-		{
-			return 1;
-		}
+		case 0x06:
+			ndata[10] = mode->datapattern;
+			switch ( mode->datapattern )
+			{
+				case SCECdSecS2328:
+					dma3_param.m_dma3_blkwords = 6;
+					dma3_param.m_dma3_blkcount *= 97;
+					dma3_param.m_cdvdreg_howto = 134;
+					break;
+				case SCECdSecS2340:
+					dma3_param.m_dma3_blkwords = 15;
+					dma3_param.m_dma3_blkcount *= 39;
+					dma3_param.m_cdvdreg_howto = 143;
+					break;
+				case SCECdSecS2048:
+				default:
+					dma3_param.m_dma3_blkwords = 32;
+					dma3_param.m_dma3_blkcount *= 16;
+					dma3_param.m_cdvdreg_howto = 128;
+					break;
+			}
+			break;
+		case 0x08:
+			dma3_param.m_dma3_blkwords = 12;
+			dma3_param.m_dma3_blkcount *= 43;
+			dma3_param.m_cdvdreg_howto = 140;
+			ndata[10] = 0;
+			break;
+		default:
+			return 0;
 	}
-	return 0;
+	return cdvdman_send_ncmd(ncmd, ndata, sizeof(ndata), ncmd == 0x06 ? 1 : 14, &dma3_param, 0) >= 0;
 }
 
 int sceCdRead0(u32 lsn, u32 sectors, void *buffer, sceCdRMode *mode, int csec, void *callback)
@@ -5066,7 +6568,7 @@ int sceCdRead0(u32 lsn, u32 sectors, void *buffer, sceCdRMode *mode, int csec, v
 	char ndata[11];
 	u32 efbits;
 
-	if ( PollEventFlag(g_ncmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( PollEventFlag(g_ncmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
@@ -5103,7 +6605,10 @@ int sceCdRead0(u32 lsn, u32 sectors, void *buffer, sceCdRMode *mode, int csec, v
 			dma3_param.m_cdvdreg_howto = 128;
 			break;
 	}
-	// The following call to sceCdGetDiskType was inlined
+		// The following call to sceCdGetDiskType was inlined
+#ifdef CDVD_VARIANT_OSD
+	g_cdvdman_istruct.m_dvd_flag = cdvdman_isdvd();
+#else
 	switch ( sceCdGetDiskType() )
 	{
 		case SCECdPSCD:
@@ -5112,7 +6617,7 @@ int sceCdRead0(u32 lsn, u32 sectors, void *buffer, sceCdRMode *mode, int csec, v
 		case SCECdPS2CDDA:
 			if ( g_cdvdman_mmode != SCECdMmodeCd && g_cdvdman_mmode != 0xFF )
 			{
-				vSetEventFlag(g_ncmd_evid, 1);
+				vSetEventFlag(g_ncmd_evfid, 1);
 				return 0;
 			}
 			g_cdvdman_istruct.m_dvd_flag = 0;
@@ -5120,15 +6625,16 @@ int sceCdRead0(u32 lsn, u32 sectors, void *buffer, sceCdRMode *mode, int csec, v
 		case SCECdPS2DVD:
 			if ( g_cdvdman_mmode != SCECdMmodeDvd && g_cdvdman_mmode != 0xFF )
 			{
-				vSetEventFlag(g_ncmd_evid, 1);
+				vSetEventFlag(g_ncmd_evfid, 1);
 				return 0;
 			}
 			g_cdvdman_istruct.m_dvd_flag = 1;
 			break;
 		default:
-			vSetEventFlag(g_ncmd_evid, 1);
+			vSetEventFlag(g_ncmd_evfid, 1);
 			return 0;
 	}
+#endif
 	g_cdvdman_istruct.m_read_mode = *mode;
 	g_cdvdman_istruct.m_read_callback = callback;
 	g_cdvdman_istruct.m_read_chunk = dma3_param.m_dma3_csectors;
@@ -5142,12 +6648,12 @@ int sceCdRead0(u32 lsn, u32 sectors, void *buffer, sceCdRMode *mode, int csec, v
 	ndata[10] = mode->datapattern;
 	dma3_param.m_dma3_maddress = buffer;
 	VERBOSE_KPRINTF(1, "Read Command call\n");
-	if ( cdvdman_send_ncmd(6, ndata, sizeof(ndata), 1, &dma3_param, 0) < 0 )
+	if ( cdvdman_send_ncmd(0x06, ndata, sizeof(ndata), 1, &dma3_param, 0) < 0 )
 	{
-		vSetEventFlag(g_ncmd_evid, 1);
+		vSetEventFlag(g_ncmd_evfid, 1);
 		return 0;
 	}
-	vSetEventFlag(g_ncmd_evid, 1);
+	vSetEventFlag(g_ncmd_evfid, 1);
 	return 1;
 }
 
@@ -5252,6 +6758,7 @@ static int cdvdman_read(u32 lsn, u32 sectors, void *buf, sceCdRMode *mode, int d
 	int state;
 	int scres_unused;
 	int dvd;
+	int ready;
 
 	dvd = cdvdman_isdvd();
 	if ( dvd )
@@ -5284,13 +6791,16 @@ static int cdvdman_read(u32 lsn, u32 sectors, void *buf, sceCdRMode *mode, int d
 		return read0_res;
 	}
 	CpuSuspendIntr(&state);
-	if ( (sceCdDiskReady(8) & 0xC0) != 0x40 || g_cdvdman_istruct.m_read2_flag )
+	ready = sceCdDiskReady(8) & 0xC0;
+	if ( ready != 0x40 || g_cdvdman_istruct.m_read2_flag )
 	{
+		// The following Kprintf was modified for ioprp300x
 		VERBOSE_KPRINTF(
 			1,
-			"sceCdRead: Double Booking error r2f= %d waf= %d\n",
+			"sceCdRead: Double Booking error r2f= %d waf= %d rdy= %02x\n",
 			g_cdvdman_istruct.m_read2_flag,
-			g_cdvdman_istruct.m_wait_flag);
+			g_cdvdman_istruct.m_wait_flag,
+			ready);
 		if ( ef1 )
 		{
 			vSetEventFlag(ef1, ef2);
@@ -5319,16 +6829,13 @@ static int cdvdman_read(u32 lsn, u32 sectors, void *buf, sceCdRMode *mode, int d
 	g_cdvdman_istruct.m_cdvdman_rsec = (sectors >= 0x41) ? (((lsn & 0xF)) ? (0x10 - (lsn & 0xF)) : 0x40) : sectors;
 	g_cdvdman_read_alarm_cb_timeout.hi = 0;
 	g_cdvdman_read_alarm_cb_timeout.lo = 0x9000 * sceCdSC(0xFFFFFFF1, &scres_unused);
-	vSetAlarm(
-		&g_cdvdman_read_alarm_cb_timeout,
-		(unsigned int (*)(void *))read_timeout_alarm_cb,
-		&g_cdvdman_read_alarm_cb_timeout);
+	vSetAlarm(&g_cdvdman_read_alarm_cb_timeout, read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
 	read_res = (dvd ? sceCdRV : sceCdRead0)(
 		lsn,
 		g_cdvdman_istruct.m_cdvdman_rsec,
 		g_cdvdman_ptoc,
 		dvd ? mode : &g_cdvdman_istruct.m_cdvdman_cdrmode,
-		0x10,
+		g_cdvdman_cache_sector_count,
 		read_cdvd_cb);
 	if ( !read_res )
 	{
@@ -5342,7 +6849,7 @@ static int cdvdman_read(u32 lsn, u32 sectors, void *buf, sceCdRMode *mode, int d
 			g_cdvdman_istruct.m_dec_state = 0;
 			sceCdDecSet(0, 0, 0);
 		}
-		vCancelAlarm((unsigned int (*)(void *))read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
+		vCancelAlarm(read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
 	}
 	if ( ef1 )
 	{
@@ -5365,15 +6872,15 @@ int sceCdRead(u32 lbn, u32 sectors, void *buffer, sceCdRMode *mode)
 	// Unofficial: initialize to 0
 	memset(&efinfo, 0, sizeof(efinfo));
 	CpuSuspendIntr(&state);
-	vReferEventFlagStatus(g_fio_fsv_evid, &efinfo);
+	vReferEventFlagStatus(g_fio_fsv_evfid, &efinfo);
 	if ( !(efinfo.currBits & 1) )
 	{
 		CpuResumeIntr(state);
 		return 0;
 	}
-	vClearEventFlag(g_fio_fsv_evid, ~1);
+	vClearEventFlag(g_fio_fsv_evfid, ~1);
 	CpuResumeIntr(state);
-	return cdvdman_read(lbn, sectors, buffer, mode, 0, 0, g_fio_fsv_evid, 1);
+	return cdvdman_read(lbn, sectors, buffer, mode, 0, 0, g_fio_fsv_evfid, 1);
 }
 
 static int cdvdman_syncdec(int decflag, int decxor, int shift, u32 data)
@@ -5383,10 +6890,10 @@ static int cdvdman_syncdec(int decflag, int decxor, int shift, u32 data)
 
 static void Read2intrCDVD(int read2_flag)
 {
-	iCancelAlarm((unsigned int (*)(void *))read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
-	if ( g_cdvdman_istruct.m_last_error || g_cdvdman_retries >= 5 )
+	iCancelAlarm(read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
+	if ( g_cdvdman_istruct.m_last_error != SCECdErNO || g_cdvdman_retries >= 5 )
 	{
-		if ( !g_cdvdman_istruct.m_last_error )
+		if ( g_cdvdman_istruct.m_last_error == SCECdErNO )
 		{
 			g_cdvdman_istruct.m_last_error = SCECdErREADCF;
 		}
@@ -5431,15 +6938,12 @@ static void Read2intrCDVD(int read2_flag)
 						 g_cdvdman_istruct.m_cdvdman_rsec,
 						 g_cdvdman_ptoc,
 						 &g_cdvdman_istruct.m_cdvdman_cdrmode,
-						 0x10,
+						 g_cdvdman_cache_sector_count,
 						 read_cdvd_cb) )
 			{
 				g_cdvdman_read_alarm_cb_timeout.hi = 0;
 				g_cdvdman_read_alarm_cb_timeout.lo = 0x9000 * sceCdSC(0xFFFFFFF1, &scres_unused);
-				iSetAlarm(
-					&g_cdvdman_read_alarm_cb_timeout,
-					(unsigned int (*)(void *))read_timeout_alarm_cb,
-					&g_cdvdman_read_alarm_cb_timeout);
+				iSetAlarm(&g_cdvdman_read_alarm_cb_timeout, read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
 			}
 			else
 			{
@@ -5489,15 +6993,12 @@ static void Read2intrCDVD(int read2_flag)
 							 g_cdvdman_istruct.m_cdvdman_rsec,
 							 g_cdvdman_ptoc,
 							 &g_cdvdman_istruct.m_cdvdman_cdrmode,
-							 0x10,
+							 g_cdvdman_cache_sector_count,
 							 read_cdvd_cb) )
 				{
 					g_cdvdman_read_alarm_cb_timeout.hi = 0;
 					g_cdvdman_read_alarm_cb_timeout.lo = 0x9000 * sceCdSC(0xFFFFFFF1, &scres_unused);
-					iSetAlarm(
-						&g_cdvdman_read_alarm_cb_timeout,
-						(unsigned int (*)(void *))read_timeout_alarm_cb,
-						&g_cdvdman_read_alarm_cb_timeout);
+					iSetAlarm(&g_cdvdman_read_alarm_cb_timeout, read_timeout_alarm_cb, &g_cdvdman_read_alarm_cb_timeout);
 				}
 				else
 				{
@@ -5557,9 +7058,16 @@ static int cdvdman_readfull(u32 lsn, u32 sectors, void *buf, const sceCdRMode *m
 	char ndata[11];
 
 	VERBOSE_KPRINTF(1, "lsn:%d nsec:%d buf:% cmdmode:%d\n", lsn, sectors, buf, flag);
+	// The following Kprintf was added for ioprp300x
+	VERBOSE_KPRINTF(1, "DA Read lsn= %d nsec= %d datapattern= %d\n", lsn, sectors, mode->datapattern);
 	g_cdvdman_readbuf = buf;
+#ifdef CDVD_VARIANT_XOSD
+	dma3_param.m_dma3_csectors = sectors;
+	dma3_param.m_dma3_msectors = (u16)sectors;
+#else
 	dma3_param.m_dma3_csectors = 0;
 	dma3_param.m_dma3_msectors = 0;
+#endif
 	dma3_param.m_dma3_callback = 0;
 	dma3_param.m_dma3_blkcount = sectors;
 	switch ( mode->datapattern )
@@ -5581,8 +7089,12 @@ static int cdvdman_readfull(u32 lsn, u32 sectors, void *buf, const sceCdRMode *m
 			dma3_param.m_cdvdreg_howto = 140;
 			break;
 	}
-	// The following call to sceCdGetDiskType() was inlined
+		// The following call to sceCdGetDiskType() was inlined
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
 	switch ( sceCdGetDiskType() )
+#endif
 	{
 		case SCECdPSCDDA:
 		case SCECdPS2CDDA:
@@ -5591,34 +7103,53 @@ static int cdvdman_readfull(u32 lsn, u32 sectors, void *buf, const sceCdRMode *m
 		default:
 			return 0;
 	}
+#ifndef CDVD_VARIANT_OSD
 	if ( g_cdvdman_mmode != SCECdMmodeCd && g_cdvdman_mmode != 0xFF )
 	{
 		return 0;
 	}
+#endif
 	*(u32 *)ndata = lsn;
 	*(u32 *)&ndata[4] = sectors;
 	ndata[8] = mode->trycount;
 	ndata[9] = cdvdman_speedctl(mode->spindlctrl, 0, lsn + sectors);
 	dma3_param.m_dma3_maddress = buf;
 	ndata[10] = mode->datapattern;
-	return cdvdman_send_ncmd((!flag) ? 7 : 14, ndata, sizeof(ndata), (!flag) ? 2 : 12, &dma3_param, 1) >= 0;
+	return cdvdman_send_ncmd((!flag) ? 0x07 : 0x0E, ndata, sizeof(ndata), (!flag) ? 2 : 12, &dma3_param, 1) >= 0;
 }
 
+// cppcheck-suppress constParameterPointer
 int sceCdReadCDDA(u32 lbn, u32 sectors, void *buffer, sceCdRMode *mode)
 {
 	return cdvdman_readfull(lbn, sectors, buffer, mode, 0);
 }
 
+#ifdef CDVD_VARIANT_OSD
+// cppcheck-suppress constParameterPointer
+int sceCdReadFull(unsigned int lsn, unsigned int sectors, void *buf, sceCdRMode *mode)
+{
+	return g_cdvdman_minver_20800 ? cdvdman_readfull(lsn, sectors, buf, mode, 1) :
+																	cdvdman_readfull(lsn, sectors, buf, mode, 0);
+}
+#endif
+
 int sceCdRV(u32 lsn, u32 sectors, void *buf, sceCdRMode *mode, int arg5, void *cb)
 {
 	cdvdman_dma3_parameter_t dma3_param;
 	char ndata[11];
 	u32 efbits;
 
-	// The following call to sceCdGetDiskType was inlined
 	if (
-		sceCdGetDiskType() != SCECdPS2DVD || (g_cdvdman_mmode != SCECdMmodeDvd && g_cdvdman_mmode != 0xFF)
-		|| (PollEventFlag(g_ncmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND) )
+#ifdef CDVD_VARIANT_XOSD
+		get_disk_type_ex() != SCECdPS2DVD
+#else
+		// The following call to sceCdGetDiskType was inlined
+		sceCdGetDiskType() != SCECdPS2DVD
+#endif
+#ifndef CDVD_VARIANT_OSD
+		|| (g_cdvdman_mmode != SCECdMmodeDvd && g_cdvdman_mmode != 0xFF)
+#endif
+		|| (PollEventFlag(g_ncmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND) )
 	{
 		return 0;
 	}
@@ -5645,92 +7176,264 @@ int sceCdRV(u32 lsn, u32 sectors, void *buf, sceCdRMode *mode, int arg5, void *c
 	dma3_param.m_dma3_callback = (int (*)(void))cb;
 	g_cdvdman_istruct.m_read_callback = cb;
 	dma3_param.m_dma3_maddress = buf;
-	if ( cdvdman_send_ncmd(8, ndata, sizeof(ndata), 14, &dma3_param, 0) < 0 )
+	if ( cdvdman_send_ncmd(0x08, ndata, sizeof(ndata), 14, &dma3_param, 0) < 0 )
 	{
-		vSetEventFlag(g_ncmd_evid, 1);
+		vSetEventFlag(g_ncmd_evfid, 1);
 		return 0;
 	}
-	vSetEventFlag(g_ncmd_evid, 1);
+	vSetEventFlag(g_ncmd_evfid, 1);
 	return 1;
 }
 
+#ifdef CDVD_VARIANT_OSD
+// cppcheck-suppress constParameterPointer
+int sceCdReadDVDV(u32 lbn, u32 sectors, void *buffer, sceCdRMode *mode)
+{
+	cdvdman_dma3_parameter_t dma3_param;
+	char ndata[11];
+
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
+	// The following call to sceCdGetDiskType was inlined
+	switch ( sceCdGetDiskType() )
+#endif
+	{
+		case SCECdPS2DVD:
+		case SCECdDVDVR:
+		case SCECdDVDV:
+			break;
+		default:
+			return 0;
+	}
+	switch ( mode->spindlctrl )
+	{
+		case SCECdSpinMax:
+		case SCECdSpinX4:
+			ndata[9] = 3;
+			break;
+		case SCECdSpinX1:
+			ndata[9] = 1;
+			break;
+		case SCECdSpinX2:
+		case 0xC:
+			ndata[9] = 4;
+			break;
+		case 0xA:
+			ndata[9] = 0x40;
+			break;
+		case 0xB:
+			ndata[9] = 2;
+			break;
+		default:
+			ndata[9] = 0x83;
+			break;
+	}
+	*(u32 *)ndata = lbn;
+	*(u32 *)&ndata[4] = sectors;
+	dma3_param.m_cdvdreg_howto = 140;
+	dma3_param.m_dma3_blkwords = 12;
+	dma3_param.m_dma3_blkcount = 43 * sectors;
+	ndata[10] = 0;
+	dma3_param.m_dma3_maddress = buffer;
+	dma3_param.m_dma3_msectors = 0;
+	dma3_param.m_dma3_csectors = 0;
+	dma3_param.m_dma3_callback = 0;
+	ndata[8] = mode->trycount;
+	return cdvdman_send_ncmd(0x08, ndata, sizeof(ndata), 9, &dma3_param, 1) >= 0;
+}
+#endif
+
 int sceCdSeek(u32 lbn)
 {
-	u32 ndata;
+	char ndata[4];
 
-	ndata = lbn;
+	*(u32 *)ndata = lbn;
 	if ( cdvdman_isdvd() )
 	{
 		if ( !DvdDual_infochk() )
 		{
 			return 0;
 		}
-		ndata = sceCdLsnDualChg(ndata);
+		*(u32 *)ndata = sceCdLsnDualChg(lbn);
 	}
-	return cdvdman_send_ncmd(5, &ndata, 4, 4, 0, 1) >= 0;
+	return cdvdman_send_ncmd(0x05, ndata, sizeof(ndata), 4, 0, 1) >= 0;
 }
 
-int sceCdRI(u8 *buffer, u32 *result)
+#ifdef CDVD_VARIANT_XOSD
+static unsigned int sceCdChgSpdlCtrl(int mode)
 {
-	int command;
-	u8 rdata[9];
+	unsigned int retval;
+	char ndata[1];
 
-	command = set_prev_command(18, 0, 0, (char *)rdata, sizeof(rdata), 1);
-	*result = rdata[0];
-	memcpy(buffer, &rdata[1], 8);
-	return command;
+	ndata[0] = mode;
+	retval = ~cdvdman_send_ncmd(0x0F, ndata, sizeof(ndata), 0xF, 0, 0);
+	VERBOSE_KPRINTF(1, "Called sceCdChgSpdlCtrl mode:%d ret= %d\n", mode & 0xFF, retval >> 31);
+	return retval >> 31;
+}
+#endif
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdRI(u8 *buffer, u32 *status)
+{
+	int retval;
+	char rdata[9];
+
+	retval = set_prev_command(0x12, NULL, 0, rdata, sizeof(rdata), 1);
+	*status = rdata[0];
+	memcpy(buffer, &rdata[1], sizeof(rdata) - 1);
+	return retval;
 }
 
 int sceCdRM(char *buffer, u32 *status)
 {
-	int command;
+	int retval;
 	int cmd_tmp2;
-	u8 rdata[9];
-	char wdata;
+	char rdata[9];
+	char wdata[1];
 	u32 efbits;
 
-	*status = 0;
-	if ( sceCdGetMVersion(rdata, status) != 1 || (unsigned int)(rdata[3] | (rdata[2] << 8) | (rdata[1] << 16)) < 0x10500 )
+	*status = SCECdErNO;
+	if ( sceCdMV((u8 *)rdata, status) != 1 || (unsigned int)(rdata[3] | (rdata[2] << 8) | (rdata[1] << 16)) < 0x10500 )
 	{
 		strcpy(buffer, "M_NAME_UNKNOWN");
 		buffer[15] = 0;
 		*status |= 0x40;
 		return 1;
 	}
-	if ( PollEventFlag(g_scmd_evid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
 	{
 		return 0;
 	}
 	DelayThread(2000);
-	wdata = 0;
-	command = set_prev_command(0x17, &wdata, sizeof(wdata), (char *)rdata, sizeof(rdata), 0);
+	wdata[0] = 0;
+	retval = set_prev_command(0x17, wdata, sizeof(wdata), rdata, sizeof(rdata), 0);
 	*status = rdata[0];
-	memcpy(buffer, &rdata[1], 8);
+	memcpy(buffer, &rdata[1], sizeof(rdata) - 1);
+	DelayThread(2000);
+	wdata[0] = 8;
+	cmd_tmp2 = set_prev_command(0x17, wdata, sizeof(wdata), rdata, sizeof(rdata), 0);
+	*status |= rdata[0];
+	memcpy(&buffer[8], &rdata[1], sizeof(rdata) - 1);
+	vSetEventFlag(g_scmd_evfid, 1);
+	return retval ? (!!cmd_tmp2) : 0;
+}
+
+#ifdef CDVD_VARIANT_OSD
+// Not implemented XOSD or DVD Player 3.11
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdWI(const u8 *buffer, u32 *status)
+{
+	int retres;
+
+	DelayThread(16000);
+	*status = SCECdErNO;
+	retres = set_prev_command(0x13, (const char *)buffer, 8, (char *)status, 1, 1);
+	DelayThread(16000);
+	return retres;
+}
+
+// Not implemented XOSD or DVD Player 3.11
+int sceCdWM(const char *buffer, u32 *status)
+{
+	int retres;
+	char rdata[1];
+	char wdata[9];
+
+	*status = SCECdErNO;
+	if ( sceCdMV((u8 *)wdata, status) != 1 || (unsigned int)(wdata[3] | (wdata[2] << 8) | (wdata[1] << 16)) < 0x10500 )
+	{
+		*status |= 0x40;
+		return 1;
+	}
 	DelayThread(2000);
-	wdata = 8;
-	cmd_tmp2 = set_prev_command(0x17, &wdata, sizeof(wdata), (char *)rdata, sizeof(rdata), 0);
+	wdata[0] = 0;
+	// The following was inlined
+	memcpy(&wdata[1], &buffer[0], sizeof(wdata) - 1);
+	retres = set_prev_command(0x18, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	*status = rdata[0];
+	DelayThread(16000);
+	wdata[0] = 8;
+	// The following was inlined
+	memcpy(&wdata[1], &buffer[8], sizeof(wdata) - 1);
+	retres = set_prev_command(0x18, wdata, sizeof(wdata), rdata, sizeof(rdata), 1) && retres;
 	*status |= rdata[0];
-	memcpy(&buffer[8], &rdata[1], 8);
-	vSetEventFlag(g_scmd_evid, 1);
-	return command ? (!!cmd_tmp2) : 0;
+	DelayThread(16000);
+	return !!retres;
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdReadConsoleID(u8 *buffer, u32 *status)
+{
+	int retval;
+	char rdata[9];
+	char wdata[1];
+
+	wdata[0] = 0x45;
+	retval = set_prev_command(0x03, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	*status = rdata[0];
+	memcpy(buffer, &rdata[1], sizeof(rdata) - 1);
+	return retval;
+}
+
+// Not implemented XOSD or DVD Player 3.11
+int sceCdWriteConsoleID(const u8 *buffer, u32 *status)
+{
+	int retval;
+	char wdata[9];
+
+	DelayThread(16000);
+	*status = SCECdErNO;
+	wdata[0] = 0x44;
+	memcpy(&wdata[1], buffer, 8);
+	retval = set_prev_command(0x03, wdata, sizeof(wdata), (char *)status, 1, 1);
+	DelayThread(16000);
+	return retval;
 }
+#endif
 
-static int sceCdGetMVersion(u8 *buffer, u32 *status)
+int sceCdMV(u8 *buffer, u32 *status)
 {
-	int command;
+	int retval;
 	char rdata[4];
 	char wdata[1];
 
-	wdata[0] = 0;
-	command = set_prev_command(3, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	wdata[0] = 0x00;
+	retval = set_prev_command(0x03, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+#ifdef CDVD_VARIANT_XOSD
+	*status = SCECdErNO;
+#else
 	*status = rdata[0] & 0x80;
+#endif
 	VERBOSE_KPRINTF(1, "MV 0x%02x,0x%02x,0x%02x,0x%02x\n", (u8)rdata[0], (u8)rdata[1], (u8)rdata[2], (u8)rdata[3]);
+#ifndef CDVD_VARIANT_XOSD
 	rdata[0] &= ~0x80;
+#endif
 	memcpy(buffer, rdata, sizeof(rdata));
-	return command;
+	return retval;
+}
+
+#ifdef CDVD_VARIANT_XOSD
+static int cdvdman_get_renewal_date(u8 *buffer, u32 *status)
+{
+	int retval;
+	char rdata[6];
+	char wdata[1];
+
+	*status = SCECdErNO;
+	wdata[0] = 0xFD;
+	retval = set_prev_command(0x03, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	if ( retval )
+	{
+		*status = (u8)rdata[0];
+	}
+	memcpy(buffer, &rdata[1], sizeof(rdata) - 1);
+	return retval;
 }
+#endif
 
-static int cdvdman_scmd_sender_03_48(u8 *buf, u32 *status)
+#ifndef CDVD_VARIANT_XOSD
+static int cdvdman_scmd_sender_03_30(u8 *buf, u32 *status)
 {
 	int retval;
 	char rdata[2];
@@ -5740,13 +7443,74 @@ static int cdvdman_scmd_sender_03_48(u8 *buf, u32 *status)
 	{
 		return 0;
 	}
-	wdata[0] = 48;
+	wdata[0] = 0x30;
 	wdata[1] = 2;
-	retval = set_prev_command(3, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	retval = set_prev_command(0x03, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
 	*status = (u8)rdata[0];
 	*buf = rdata[1];
 	return retval;
 }
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+int sceCdReadSUBQ(void *buffer, u32 *status)
+{
+	int retval;
+	int i;
+	int dev5_reg_00E;
+	int dev5_reg_00D;
+	int dev5_reg_00C;
+	char rdata[11];
+	u32 efbits;
+	USE_DEV5_MMIO_HWPORT();
+
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	{
+		return 0;
+	}
+	dev5_mmio_hwport->m_dev5_reg_009 = 0;
+	retval = cdvdman_send_scmd2(0x02, NULL, 0, rdata, sizeof(rdata), 0);
+	memcpy(buffer, &rdata[1], sizeof(rdata) - 1);
+	for ( i = 0; i < 10; i += 1 )
+	{
+		int tmp00E;
+		int tmp00D;
+		int tmp00C;
+
+		dev5_reg_00E = dev5_mmio_hwport->m_dev5_reg_00E;
+		dev5_reg_00D = dev5_mmio_hwport->m_dev5_reg_00D;
+		dev5_reg_00C = dev5_mmio_hwport->m_dev5_reg_00C;
+		tmp00E = dev5_mmio_hwport->m_dev5_reg_00E;
+		tmp00D = dev5_mmio_hwport->m_dev5_reg_00D;
+		tmp00C = dev5_mmio_hwport->m_dev5_reg_00C;
+		if ( dev5_reg_00E == tmp00E && dev5_reg_00D == tmp00D && dev5_reg_00C == tmp00C )
+		{
+			break;
+		}
+	}
+	if ( i != 10 )
+	{
+		*((u8 *)buffer + 9) = dev5_reg_00E;
+		*((u8 *)buffer + 8) = dev5_reg_00D;
+		*((u8 *)buffer + 7) = dev5_reg_00C;
+	}
+	*status = rdata[0];
+	vSetEventFlag(g_scmd_evfid, 1);
+	return retval;
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdForbidDVDP(u32 *status)
+{
+	int retval;
+	char rdata[1];
+
+	// Unofficial: NULL for wdata if length is 0
+	retval = set_prev_command(0x15, NULL, 0, rdata, sizeof(rdata), 1);
+	*status = (u8)rdata[0];
+	return retval;
+}
+#endif
 
 int sceCdMmode(int media)
 {
@@ -5754,27 +7518,61 @@ int sceCdMmode(int media)
 	return 1;
 }
 
-int sceCdCancelPOffRdy(u32 *result)
+#ifdef CDVD_VARIANT_OSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdForbidRead(u32 *status)
 {
-	char wdata[8];
+	*status = SCECdErNO;
+	// Unofficial: NULL for wdata if length is 0
+	return set_prev_command(0x19, NULL, 0, (char *)status, 1, 1);
+}
 
-	memset(wdata, 0, sizeof(wdata));
-	*result = 0;
-	return g_cdvdman_minver_20400 ? set_prev_command(27, wdata, 0, (char *)result, 1, 1) : 1;
+int sceCdBootCertify(const u8 *romname)
+{
+	char rdata[1];
+
+	VERBOSE_KPRINTF(1, "BC %d %d %d %d\n", *romname, romname[1], romname[2], romname[3]);
+	return set_prev_command(0x1A, (const char *)romname, 4, rdata, sizeof(rdata), 1);
+}
+#endif
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdCancelPOffRdy(u32 *status)
+{
+	*status = SCECdErNO;
+	// Unofficial: NULL for wdata if length is 0
+	return g_cdvdman_minver_20400 ? set_prev_command(0x1B, NULL, 0, (char *)status, 1, 1) : 1;
+}
+
+#ifdef CDVD_VARIANT_OSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdBlueLEDCtl(u8 control, u32 *status)
+{
+	char wdata[1];
+
+	*status = SCECdErNO;
+	wdata[0] = control;
+	return set_prev_command(0x1C, wdata, sizeof(wdata), (char *)status, 1, 1);
 }
+#endif
 
-static unsigned int power_off_alarm_cb(cdvdman_internal_struct_t *s)
+static unsigned int power_off_alarm_cb(void *userdata)
 {
+	cdvdman_internal_struct_t *s;
+
+	s = (cdvdman_internal_struct_t *)userdata;
 	s->m_power_flag = 0;
 	return 0;
 }
 
-int sceCdPowerOff(u32 *result)
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdPowerOff(u32 *status)
 {
-	int command;
+	int retval;
 
-	*result = 0;
+	*status = SCECdErNO;
 	VERBOSE_KPRINTF(1, "sceCdPowerOff Call\n");
+#ifndef CDVD_VARIANT_XOSD
 	if ( !g_cdvdman_minver_x_model_15 )
 	{
 		while ( (sceCdStatus() & SCECdStatShellOpen) )
@@ -5785,8 +7583,9 @@ int sceCdPowerOff(u32 *result)
 			vDelayThread(250000);
 		}
 	}
-	command = set_prev_command(0xF, 0, 0, (char *)result, 1, 1);
-	if ( !command )
+#endif
+	retval = set_prev_command(0x0F, NULL, 0, (char *)status, 1, 1);
+	if ( !retval )
 	{
 		g_cdvdman_istruct.m_power_flag = 0;
 		return 0;
@@ -5795,40 +7594,371 @@ int sceCdPowerOff(u32 *result)
 	g_cdvdman_istruct.m_power_flag = 1;
 	g_cdvdman_power_off_timeout.hi = 0;
 	g_cdvdman_power_off_timeout.lo = 0xAFC8000;
-	vSetAlarm(&g_cdvdman_power_off_timeout, (unsigned int (*)(void *))power_off_alarm_cb, &g_cdvdman_istruct);
-	return command;
+	vSetAlarm(&g_cdvdman_power_off_timeout, power_off_alarm_cb, &g_cdvdman_istruct);
+	return retval;
 }
 
 int sceCdCtrlADout(int mode, u32 *status)
 {
-	char wdata;
+	char wdata[1];
 
-	wdata = mode;
-	*status = 0;
+	*status = SCECdErNO;
 	DelayThread(2000);
-	VERBOSE_KPRINTF(1, "Audio Digital Out: Set param %d\n", wdata);
-	return set_prev_command(20, &wdata, sizeof(wdata), (char *)status, 1, 1);
+	VERBOSE_KPRINTF(1, "Audio Digital Out: Set param %d\n", (u8)mode);
+	wdata[0] = mode;
+	return set_prev_command(0x14, wdata, sizeof(wdata), (char *)status, 1, 1);
 }
 
-int sceCdReadClock(sceCdCLOCK *clock)
+#ifdef CDVD_VARIANT_OSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdAutoAdjustCtrl(int mode, u32 *status)
 {
-	int retval;
+	char wdata[1];
 
-	retval = set_prev_command(8, 0, 0, (char *)clock, 8, 1);
-	clock->pad = 0;
-	clock->month &= 0x7F;
-	if ( retval && !clock->stat )
+	*status = SCECdErNO;
+	DelayThread(2000);
+	VERBOSE_KPRINTF(1, "Auto Adjust Ctrl: Set param %d\n", (u8)mode);
+	wdata[0] = mode;
+	return set_prev_command(0x16, wdata, sizeof(wdata), (char *)status, 1, 1);
+}
+
+// TODO clock argument not const
+int sceCdWriteWakeUpTime(const sceCdCLOCK *clock, u16 userdata, int flags)
+{
+	unsigned int clkmonth;
+	unsigned int clkday;
+	char wdata[8];
+
+	if ( !g_cdvdman_minver_50000 )
 	{
-		memcpy(&g_cdvdman_clock, clock, sizeof(g_cdvdman_clock));
-		g_cdvdman_clk_flg = 1;
+		return 0;
 	}
-	else if ( g_cdvdman_clk_flg )
+	clkmonth = 10 * (clock->month >> 4) + (clock->month & 0xF);
+	clkday = 10 * (clock->day >> 4) + (clock->day & 0xF);
+	if (
+		(10 * (clock->second >> 4) + (clock->second & 0xF) >= 0x3C
+		 || 10 * (clock->minute >> 4) + (clock->minute & 0xF) >= 0x3C
+		 || 10 * (clock->hour >> 4) + (clock->hour & 0xF) >= 0x18 || 10 * (clock->year >> 4) + (clock->year & 0xF) >= 0x64
+		 || clkmonth >= 0xD || !clkmonth || clkday >= 0x20 || !clkday)
+		&& flags != 255 && !(clock->second & 0x80) && !(clock->minute & 0x80) )
 	{
-		memcpy(clock, &g_cdvdman_clock, sizeof(g_cdvdman_clock));
+		return 0;
 	}
-	else
-	{
-		clock->month = 3;
+	wdata[0] = (flags == 255) ? 255 : clock->second;
+	wdata[1] = clock->minute | ((flags == 1) ? 0x80 : 0);
+	wdata[2] = clock->hour;
+	wdata[3] = clock->day;
+	wdata[4] = clock->month;
+	wdata[5] = clock->year;
+	wdata[6] = userdata & 0xFF;
+	wdata[7] = (userdata >> 8) & 0xFF;
+	return set_prev_command(0x21, wdata, sizeof(wdata), (char *)&clock->stat, sizeof(clock->stat), 1);
+}
+
+int sceCdReadWakeUpTime(sceCdCLOCK *clock, u16 *userdata, u32 *wakeupreason, int *flags)
+{
+	int retval;
+	char rdata[10];
+
+	clock->year = 0;
+	clock->month = 0;
+	clock->day = 0;
+	clock->pad = 0;
+	clock->hour = 0;
+	clock->minute = 0;
+	clock->second = 0;
+	clock->stat = 0;
+	*userdata = 0;
+	*wakeupreason = 0;
+	*flags = 0;
+	if ( !g_cdvdman_minver_50000 )
+	{
+		*wakeupreason = 256;
+		return 1;
+	}
+	retval = set_prev_command(0x22, NULL, 0, rdata, sizeof(rdata), 1);
+	if ( !retval )
+	{
+		return 0;
+	}
+	clock->stat = rdata[0];
+	clock->second = (u8)rdata[2] == 255 ? -1 : (rdata[2] & 0x7F);
+	clock->minute = rdata[3] & 0x7F;
+	clock->pad = 0;
+	clock->hour = rdata[4];
+	clock->day = rdata[5];
+	clock->month = rdata[6];
+	clock->year = rdata[7];
+	*userdata = (u8)rdata[8] | ((u8)rdata[9] << 8);
+	*wakeupreason = (u8)rdata[1];
+	*flags = (((u8)rdata[2] >> 7) << 1) | (!!(rdata[3] & 0x80));
+	return retval;
+}
+
+int sceCdSendSCmd1D(int *arg1, unsigned int *arg2, unsigned int *arg3, u32 *status)
+{
+	int retval;
+	char rdata[5];
+	u32 rdata2tmp;
+
+	*arg3 = 0;
+	*arg2 = 0;
+	*arg1 = 0;
+	if ( !g_cdvdman_minver_50000 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x1D, NULL, 0, rdata, sizeof(rdata), 1);
+	if ( retval != 1 )
+	{
+		return retval;
+	}
+	*status = (u8)rdata[0];
+	*arg1 = (u8)rdata[1];
+	rdata2tmp = rdata[4] | (rdata[3] << 8) | (rdata[2] << 16);
+	switch ( *arg1 )
+	{
+		case 12:
+			*arg2 = (rdata2tmp >> 17) & 0x7F;
+			*arg3 = (rdata2tmp >> 12) & 0x1F;
+			return 1;
+		case 15:
+			*arg2 = (rdata2tmp >> 17) & 0x7F;
+			*arg3 = (rdata2tmp >> 9) & 0xFF;
+			return 1;
+		case 20:
+			*arg2 = (rdata2tmp >> 17) & 0x7F;
+			*arg3 = (rdata2tmp >> 4) & 0x1FFF;
+			return 1;
+		default:
+			return 0;
+	}
+}
+
+int sceRemote2_7(u16 param, u32 *status)
+{
+	char wdata[2];
+
+	if ( !g_cdvdman_minver_50000 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = param & 0xFF;
+	wdata[1] = (param >> 8) & 0xFF;
+	return set_prev_command(0x1F, wdata, sizeof(wdata), (char *)status, 1, 1);
+}
+
+int sceRemote2_7Get(u32 *param, u32 *status)
+{
+	int retval;
+	char rdata[3];
+
+	*param = 0;
+	if ( !g_cdvdman_minver_50000 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x26, NULL, 0, rdata, sizeof(rdata), 1);
+	*param = ((u8)rdata[2] << 8) | (u8)rdata[1];
+	*status = (u8)rdata[0];
+	return retval;
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdReadPS1BootParam(u8 *out, u32 *status)
+{
+	int retval;
+	char rdata[13];
+
+	memset(out, 0, 11);
+	if ( !g_cdvdman_minver_50200 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x27, NULL, 0, (char *)rdata, sizeof(rdata), 1);
+	memcpy(out, &rdata[1], sizeof(rdata) - 2);
+	*status = rdata[0];
+	return retval;
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdSetFanProfile(u8 param, u32 *status)
+{
+	int retval;
+	char rdata[1];
+	char wdata[1];
+
+	if ( !g_cdvdman_minver_50400 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = param;
+	retval = set_prev_command(0x28, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	*status = (u8)rdata[0];
+	return retval;
+}
+
+int cdvdman_152(u32 *param, u32 *status)
+{
+	int retval;
+	char rdata[3];
+	char wdata[1];
+
+	if ( !g_cdvdman_minver_50400 )
+	{
+		*status = 256;
+		*param = 0;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = 0xEF;
+	retval = set_prev_command(0x03, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	*param = 3125 * (((u8)rdata[2] | ((u8)rdata[1] << 8)) << 16 >> 18) / 100;
+	*status = (u8)rdata[0];
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdNoticeGameStart(u8 arg1, u32 *status)
+{
+	int retval;
+	char rdata[1];
+	char wdata[1];
+
+	if ( !g_cdvdman_minver_50400 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = arg1;
+	retval = set_prev_command(0x29, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	*status = (u8)rdata[0];
+	if ( retval && !rdata[0] )
+	{
+		g_cdvdman_istruct.m_medium_removal_state = 0;
+	}
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+int sceCdRcBypassCtl(int mode, u32 *status)
+{
+	char wdata[1];
+	USE_IOP_MMIO_HWPORT();
+
+	if ( mfc0(PRID) >= 0x23 )
+	{
+		if ( mode & 0xFF )
+		{
+			/* 0xBF808284 */ *(u32 *)&iop_mmio_hwport->sio2.unused[0] |= 1;
+		}
+		else
+		{
+			/* 0xBF808284 */ *(u32 *)&iop_mmio_hwport->sio2.unused[0] &= ~1;
+		}
+		*status = SCECdErNO;
+		return 1;
+	}
+	if ( !g_cdvdman_minver_50000 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = mode;
+	return set_prev_command(0x24, wdata, sizeof(wdata), (char *)status, 1, 1);
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdReadRegionParams(u32 *param, u32 *status)
+{
+	int retval;
+	char rdata[15];
+
+	memset(param, 0, 15);
+	if ( !g_cdvdman_minver_60000 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x36, NULL, 0, rdata, sizeof(rdata), 1);
+	memcpy(param, &rdata[1], sizeof(rdata) - 1);
+	*status = rdata[0];
+	return retval;
+}
+
+// Not implemented XOSD or DVD Player 3.11
+// TODO const arg2 arg3
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdWriteRegionParams(u8 arg1, u32 *arg2, u8 *arg3, u32 *status)
+{
+	char wdata[15];
+
+	*status = SCECdErNO;
+	memset(wdata, 0, sizeof(wdata));
+	if ( !g_cdvdman_minver_60600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	wdata[0] = arg1;
+	// The following was inlined
+	memcpy(&wdata[1], arg2, 12);
+	// The following was inlined
+	memcpy(&wdata[13], arg3, 2);
+	return set_prev_command(0x3E, wdata, sizeof(wdata), (char *)status, 1, 1);
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdSetLEDsMode(u32 param, u32 *status)
+{
+	char wdata[1];
+
+	if ( !g_cdvdman_minver_50000 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = param;
+	return set_prev_command(0x25, wdata, sizeof(wdata), (char *)status, 1, 1);
+}
+#endif
+
+int sceCdReadClock(sceCdCLOCK *clock)
+{
+	int retval;
+
+	retval = set_prev_command(0x08, NULL, 0, (char *)clock, 8, 1);
+	clock->pad = 0;
+	clock->month &= 0x7F;
+	if ( retval && !clock->stat )
+	{
+		memcpy(&g_cdvdman_clock, clock, sizeof(g_cdvdman_clock));
+		g_cdvdman_clk_flg = 1;
+	}
+	else if ( g_cdvdman_clk_flg )
+	{
+		memcpy(clock, &g_cdvdman_clock, sizeof(g_cdvdman_clock));
+	}
+	else
+	{
+		clock->month = 3;
 		clock->day = 4;
 		clock->hour = 5;
 		clock->minute = 6;
@@ -5840,13 +7970,53 @@ int sceCdReadClock(sceCdCLOCK *clock)
 
 int sceCdRC(sceCdCLOCK *clock)
 {
-	return set_prev_command(8, 0, 0, (char *)clock, 8, 1);
+	return set_prev_command(0x08, NULL, 0, (char *)clock, 8, 1);
+}
+
+#ifdef CDVD_VARIANT_OSD
+int sceCdWriteClock(sceCdCLOCK *clock)
+{
+	return set_prev_command(
+		0x09, (const char *)&clock->second, sizeof(clock) - 1, (char *)&clock->stat, sizeof(clock->second), 1);
+}
+
+int sceCdReadNVM(u32 address, u16 *data, u8 *result)
+{
+	int retval;
+	char rdata[3];
+	char wdata[2];
+
+	wdata[0] = (address >> 8) & 0xFF;
+	wdata[1] = address & 0xFF;
+	retval = set_prev_command(0x0A, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	*result = rdata[0];
+	*data = (rdata[1] << 8) | rdata[2];
+	VERBOSE_KPRINTF(1, "RN_call addr= 0x%04x data= 0x%04x stat= 0x%02x\n", address, *data, *result);
+	return retval;
+}
+
+int sceCdWriteNVM(u32 address, u16 data, u8 *result)
+{
+	int retval;
+	char wdata[4];
+
+	wdata[0] = (address >> 8) & 0xFF;
+	wdata[1] = address & 0xFF;
+	wdata[2] = (data >> 8) & 0xFF;
+	wdata[3] = data & 0xFF;
+	retval = set_prev_command(0x0B, wdata, sizeof(wdata), (char *)result, 1, 1);
+	VERBOSE_KPRINTF(1, "WN_call addr= 0x%04x data= 0x%04x stat= 0x%02x\n", address, data, *result);
+	return retval;
 }
+#endif
 
 int sceCdTrayReq(int param, u32 *traychk)
 {
-	char wdata;
-	char rdata;
+	char wdata[1];
+	char rdata[1];
+#ifdef CDVD_VARIANT_XOSD
+	int state;
+#endif
 
 	if ( param == SCECdTrayCheck )
 	{
@@ -5858,28 +8028,41 @@ int sceCdTrayReq(int param, u32 *traychk)
 	{
 		return 1;
 	}
-	wdata = param;
+	wdata[0] = param;
 	g_cdvdman_iocache = 0;
-	if ( set_prev_command(6, &wdata, sizeof(wdata), &rdata, sizeof(rdata), 1) && !rdata )
+#ifdef CDVD_VARIANT_XOSD
+	CpuSuspendIntr(&state);
+#endif
+	rdata[0] = !!set_prev_command(0x06, wdata, sizeof(wdata), rdata, sizeof(rdata), 1) && !rdata[0];
+#ifdef CDVD_VARIANT_XOSD
+	CpuResumeIntr(state);
+#endif
+	if ( rdata[0] )
 	{
+#ifdef CDVD_VARIANT_XOSD
+		if ( !param )
+		{
+			g_cdvdman_istruct.m_medium_removal_state = 0;
+			g_cdvdman_istruct.m_atapi_disk_ejected = 0;
+		}
+#endif
 		vDelayThread(11000);
-		return 1;
 	}
-	return 0;
+	return rdata[0];
 }
 
 static int cdvdman_scmd_sender_3B(int arg1)
 {
-	char wdata;
-	char rdata;
+	char wdata[1];
+	char rdata[1];
 
 	if ( g_cdvdman_minver_x_model_15 && arg1 == 1 )
 	{
 		return 1;
 	}
-	wdata = arg1;
 	g_cdvdman_iocache = 0;
-	if ( set_prev_command(59, &wdata, sizeof(wdata), &rdata, sizeof(rdata), 1) && !rdata )
+	wdata[0] = arg1;
+	if ( set_prev_command(0x3B, wdata, sizeof(wdata), rdata, sizeof(rdata), 1) && !rdata[0] )
 	{
 		vDelayThread(11000);
 		return 1;
@@ -5891,16 +8074,17 @@ static int cdvdman_scmd_sender_3B(int arg1)
 int sceCdReadDiskID(unsigned int *id)
 {
 	sceCdRMode rmode;
-	char sectbuf[2048];
+	char sectbuf[0x800];
 	u32 efbits;
 	USE_DEV5_MMIO_HWPORT();
 
-	*((u8 *)id + 4) = 0;
-	*((u8 *)id + 3) = 0;
-	*((u8 *)id + 2) = 0;
-	*((u8 *)id + 1) = 0;
-	*(u8 *)id = 0;
+	// The following was inlined
+	memset(id, 0, 5);
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
 	switch ( sceCdGetDiskType() )
+#endif
 	{
 		case SCECdPS2CD:
 		case SCECdPS2CDDA:
@@ -5909,7 +8093,7 @@ int sceCdReadDiskID(unsigned int *id)
 		default:
 			return 0;
 	}
-	rmode.spindlctrl = 18;
+	rmode.spindlctrl = 0x12;
 	rmode.datapattern = SCECdSecS2048;
 	rmode.trycount = 0;
 	sceCdRead0(0x4B, 1, sectbuf, &rmode, 0, 0);
@@ -5919,14 +8103,14 @@ int sceCdReadDiskID(unsigned int *id)
 		return 0;
 	}
 	sceCdSync(3);
-	if ( g_cdvdman_istruct.m_last_error )
+	if ( g_cdvdman_istruct.m_last_error != SCECdErNO )
 	{
 		return 0;
 	}
-	WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+	WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 	if ( !(dev5_mmio_hwport->m_dev5_reg_038 & 4) )
 	{
-		vSetEventFlag(g_scmd_evid, 1);
+		vSetEventFlag(g_scmd_evfid, 1);
 		return 0;
 	}
 	*(u8 *)id = dev5_mmio_hwport->m_dev5_reg_030 ^ dev5_mmio_hwport->m_dev5_reg_039;
@@ -5934,13 +8118,13 @@ int sceCdReadDiskID(unsigned int *id)
 	*((u8 *)id + 2) = dev5_mmio_hwport->m_dev5_reg_032 ^ dev5_mmio_hwport->m_dev5_reg_039;
 	*((u8 *)id + 3) = dev5_mmio_hwport->m_dev5_reg_033 ^ dev5_mmio_hwport->m_dev5_reg_039;
 	*((u8 *)id + 4) = dev5_mmio_hwport->m_dev5_reg_034 ^ dev5_mmio_hwport->m_dev5_reg_039;
-	vSetEventFlag(g_scmd_evid, 1);
+	vSetEventFlag(g_scmd_evfid, 1);
 	return 1;
 }
 
 int sceCdDoesUniqueKeyExist(u32 *status)
 {
-	int disktype_tmp;
+	int is_cd;
 	u8 dev5_reg_038;
 	sceCdRMode rmode;
 	char ndata[7];
@@ -5948,20 +8132,24 @@ int sceCdDoesUniqueKeyExist(u32 *status)
 	u32 efbits;
 	USE_DEV5_MMIO_HWPORT();
 
-	disktype_tmp = 0;
 	if ( !g_cdvdman_istruct.m_cd_inited )
 	{
 		*status = SCECdErCUD;
 		return 0;
 	}
-	*status = 0;
+	*status = SCECdErNO;
+#ifdef CDVD_VARIANT_XOSD
+	switch ( get_disk_type_ex() )
+#else
 	switch ( sceCdGetDiskType() )
+#endif
 	{
 		case SCECdPS2CD:
 		case SCECdPS2CDDA:
-			disktype_tmp = 1;
+			is_cd = 1;
 			break;
 		case SCECdPS2DVD:
+			is_cd = 0;
 			break;
 		default:
 			*status = SCECdErCUD;
@@ -5985,10 +8173,10 @@ int sceCdDoesUniqueKeyExist(u32 *status)
 		sceCdSync(3);
 	}
 	CpuSuspendIntr(&state);
-	rmode.spindlctrl = 18;
+	rmode.spindlctrl = 0x12;
 	rmode.datapattern = SCECdSecS2048;
 	rmode.trycount = 0;
-	if ( disktype_tmp )
+	if ( is_cd )
 	{
 		unsigned int i;
 
@@ -6007,60 +8195,678 @@ int sceCdDoesUniqueKeyExist(u32 *status)
 		CpuResumeIntr(state);
 		sceCdSync(3);
 	}
-	WaitEventFlag(g_scmd_evid, 1, WEF_AND, &efbits);
+	WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
 	CpuSuspendIntr(&state);
 	if ( g_cdvdman_istruct.m_stream_flag || g_cdvdman_istruct.m_read2_flag )
 	{
 		*status = SCECdErREADCF;
 		CpuResumeIntr(state);
-		vSetEventFlag(g_scmd_evid, 1);
+		vSetEventFlag(g_scmd_evfid, 1);
 		return 0;
 	}
-	strcpy(&ndata[3], "K");
-	ndata[6] = 0;
-	ndata[5] = 0;
-	ndata[2] = 0;
-	ndata[1] = 0;
-	ndata[0] = 0;
-	if ( cdvdman_send_ncmd(12, ndata, sizeof(ndata), 0, 0, 1) < 0 )
+	// The following was inlined
+	memset(ndata, 0, sizeof(ndata));
+	ndata[3] = 0x4B;
+	if ( cdvdman_send_ncmd(0x0C, ndata, sizeof(ndata), 0, 0, 1) < 0 )
 	{
 		*status = SCECdErREADCF;
 		CpuResumeIntr(state);
-		vSetEventFlag(g_scmd_evid, 1);
+		vSetEventFlag(g_scmd_evfid, 1);
 		return 0;
 	}
 	CpuResumeIntr(state);
 	sceCdSync(3);
-	if ( g_cdvdman_istruct.m_last_error )
+	if ( g_cdvdman_istruct.m_last_error != SCECdErNO )
 	{
 		*status = (u8)g_cdvdman_istruct.m_last_error;
-		vSetEventFlag(g_scmd_evid, 1);
+		vSetEventFlag(g_scmd_evfid, 1);
 		return 0;
 	}
 	dev5_reg_038 = dev5_mmio_hwport->m_dev5_reg_038;
-	vSetEventFlag(g_scmd_evid, 1);
+	vSetEventFlag(g_scmd_evfid, 1);
 	return (dev5_reg_038 & 5) == 5;
 }
-
-static int cdvdman_ncmd_sender_0C(int arg1, u32 arg2, u32 arg3)
-{
-	char ndata[7];
-
-	ndata[1] = !!arg2;
-	ndata[0] = arg1;
-	ndata[2] = !!(arg2 >> 8);
-	*(u32 *)&ndata[3] = !arg1 ? arg3 : 0;
-	return cdvdman_send_ncmd(12, ndata, sizeof(ndata), 0, 0, 1) >= 0;
-}
 #endif
 
-int sceCdDecSet(u8 enable_xor, u8 enable_shift, u8 shiftval)
+#ifdef CDVD_VARIANT_XOSD
+int sceCdDeobfuscateUsingUniqueKey(u8 *buffer, unsigned int shiftval, int xorval, u32 *status)
 {
-#ifdef CDVD_VARIANT_DNAS
+	int is_cd;
+	int retval;
+	int i;
+	u8 xor_val_1_stk;
+	u8 xor_val_2_stk;
+	u8 xor_val_3_stk;
+	u8 xor_val_4_stk;
+	u8 xor_val_1_xstk;
+	u8 xor_val_2_xstk;
+	char xorarea[16];
+	char ndata[7];
+	sceCdRMode rmode;
+	int state;
+	u32 efbits;
 	USE_DEV5_MMIO_HWPORT();
 
-	g_cdvdman_cd36key = enable_shift | shiftval;
-	dev5_mmio_hwport->m_dev5_reg_03A = (16 * (shiftval & 7)) | ((!!enable_xor) << 1) | (!!enable_shift);
-#endif
-	return 1;
-}
+	memset(xorarea, 0, sizeof(xorarea));
+	memset(buffer, 0, 16);
+	*status = SCECdErNO;
+	if ( shiftval >= 8 || xorval < 0 || xorval >= 256 )
+	{
+		*status = SCECdErREADCF;
+		return 0;
+	}
+	if ( !g_cdvdman_istruct.m_cd_inited )
+	{
+		*status = SCECdErCUD;
+		return 0;
+	}
+	switch ( get_disk_type_ex() )
+	{
+		case SCECdPS2CD:
+		case SCECdPS2CDDA:
+			is_cd = 1;
+			break;
+		case SCECdPS2DVD:
+			is_cd = 0;
+			break;
+		default:
+			*status = SCECdErCUD;
+			return 0;
+	}
+	CpuSuspendIntr(&state);
+	if ( g_cdvdman_istruct.m_stream_flag || g_cdvdman_istruct.m_read2_flag )
+	{
+		*status = SCECdErREADCF;
+		CpuResumeIntr(state);
+		return 0;
+	}
+	if ( !(sceCdStatus() & SCECdStatSpin) )
+	{
+		dev5_mmio_hwport->m_dev5_reg_007 = 1;
+		CpuResumeIntr(state);
+		sceCdSync(3);
+		CpuSuspendIntr(&state);
+	}
+	if ( g_cdvdman_istruct.m_stream_flag || g_cdvdman_istruct.m_read2_flag )
+	{
+		*status = SCECdErREADCF;
+		CpuResumeIntr(state);
+		return 0;
+	}
+	rmode.spindlctrl = 0x12;
+	rmode.datapattern = SCECdSecS2048;
+	rmode.trycount = 0;
+	if ( is_cd )
+	{
+		for ( i = 0; i < 0x14; i += 1 )
+		{
+			sceCdRead0(75 + 16 * i, 0x10, g_cdvdman_ptoc, &rmode, 0, 0);
+			CpuResumeIntr(state);
+			sceCdSync(3);
+			CpuSuspendIntr(&state);
+		}
+		CpuResumeIntr(state);
+	}
+	else
+	{
+		sceCdRead0(0x4B, 1, g_cdvdman_ptoc, &rmode, 0, 0);
+		CpuResumeIntr(state);
+		sceCdSync(3);
+	}
+	WaitEventFlag(g_scmd_evfid, 1, 0, &efbits);
+	CpuSuspendIntr(&state);
+	if ( g_cdvdman_istruct.m_stream_flag || g_cdvdman_istruct.m_read2_flag )
+	{
+		*status = SCECdErREADCF;
+		CpuResumeIntr(state);
+		vSetEventFlag(g_scmd_evfid, 1);
+		return 0;
+	}
+	// The following was inlined
+	memset(ndata, 0, sizeof(ndata));
+	ndata[3] = 0x4B;
+	if ( cdvdman_send_ncmd(0x0C, ndata, sizeof(ndata), 0, 0, 1) < 0 )
+	{
+		*status = SCECdErREADCF;
+		CpuResumeIntr(state);
+		vSetEventFlag(g_scmd_evfid, 1);
+		return 0;
+	}
+	CpuResumeIntr(state);
+	sceCdSync(3);
+	if ( g_cdvdman_istruct.m_last_error != SCECdErNO )
+	{
+		*status = (u8)g_cdvdman_istruct.m_last_error;
+		vSetEventFlag(g_scmd_evfid, 1);
+		return 0;
+	}
+	retval = 0;
+	xor_val_2_xstk = 0;
+	xor_val_1_xstk = 0;
+	xor_val_4_stk = 0;
+	xor_val_3_stk = 0;
+	xor_val_2_stk = 0;
+	xor_val_1_stk = 0;
+	if ( (dev5_mmio_hwport->m_dev5_reg_038 & 5) == 5 )
+	{
+		u8 dev5_reg_020;
+		u8 dev5_reg_039;
+		u8 dev5_reg_022;
+		u8 reg_039_tmp1;
+
+		dev5_reg_020 = dev5_mmio_hwport->m_dev5_reg_020;
+		dev5_reg_039 = dev5_mmio_hwport->m_dev5_reg_039;
+		xor_val_1_stk = dev5_reg_020 ^ dev5_reg_039;
+		xor_val_2_stk = dev5_reg_039 ^ dev5_mmio_hwport->m_dev5_reg_021;
+		dev5_reg_022 = dev5_mmio_hwport->m_dev5_reg_022;
+		reg_039_tmp1 = dev5_mmio_hwport->m_dev5_reg_039;
+		xor_val_3_stk = dev5_reg_022 ^ reg_039_tmp1;
+		xor_val_4_stk = reg_039_tmp1 ^ dev5_mmio_hwport->m_dev5_reg_023;
+		xor_val_1_xstk = dev5_mmio_hwport->m_dev5_reg_024 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		xor_val_2_xstk = dev5_mmio_hwport->m_dev5_reg_039 ^ dev5_mmio_hwport->m_dev5_reg_034;
+		retval = 1;
+	}
+	vSetEventFlag(g_scmd_evfid, 1);
+	xorarea[0] = (xor_val_4_stk >> 4) | ((xor_val_1_xstk << 4) & 0x70);
+	xorarea[1] = (xor_val_3_stk >> 5) | ((xor_val_4_stk << 3) & 0x78);
+	xorarea[2] = (xor_val_2_stk >> 6) | ((xor_val_3_stk << 2) & 0x7C);
+	xorarea[3] = (xor_val_1_stk >> 7) | ((xor_val_2_stk << 1) & 0x7E);
+	sprintf(&xorarea[4], "%d", ((xor_val_1_stk & 0x7F) << 10) | (xor_val_1_xstk >> 3) | ((xor_val_2_xstk >> 3) << 5));
+	for ( i = 0; i < 9; i += 1 )
+	{
+		xorarea[i] = xorarea[i] ^ xorval;
+	}
+	if ( shiftval )
+	{
+		for ( i = 0; i < 9; i += 1 )
+		{
+			buffer[i] = (xorarea[i] << shiftval) | ((int)(u8)xorarea[i ? i - 1 : 8] >> (8 - shiftval));
+		}
+	}
+	else
+	{
+		// The following was inlined
+		memcpy(buffer, xorarea, sizeof(xorarea));
+	}
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_OSD
+int sceCdReadKey(u8 arg1, u8 arg2, unsigned int command, u8 *key)
+{
+	int i;
+	u8 dev5_reg_038;
+	sceCdRMode rmode;
+	char sectorbuf[0x800];
+	u32 efbits;
+	USE_DEV5_MMIO_HWPORT();
+
+	if ( cdvdman_isdvd() && !arg1 )
+	{
+		if ( !DvdDual_infochk() )
+		{
+			return 0;
+		}
+		command = sceCdLsnDualChg(command);
+	}
+	rmode.spindlctrl = 0x12;
+	rmode.datapattern = SCECdSecS2048;
+	rmode.trycount = 0;
+	sceCdRead0(command, 1, sectorbuf, &rmode, 0, 0);
+	sceCdSync(3);
+	for ( i = 0; i < 300; i += 1 )
+	{
+		if ( !cdvdman_ncmd_sender_0C(arg1, arg2, command + i) )
+		{
+			return 0;
+		}
+		sceCdSync(3);
+		if ( g_cdvdman_istruct.m_last_error == SCECdErNO )
+		{
+			break;
+		}
+	}
+	WaitEventFlag(g_scmd_evfid, 1, WEF_AND, &efbits);
+	// The following was inlined
+	memset(key, 0, 16);
+	dev5_reg_038 = dev5_mmio_hwport->m_dev5_reg_038;
+	if ( (dev5_reg_038 & 1) )
+	{
+		key[0] = dev5_mmio_hwport->m_dev5_reg_020 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[1] = dev5_mmio_hwport->m_dev5_reg_021 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[2] = dev5_mmio_hwport->m_dev5_reg_022 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[3] = dev5_mmio_hwport->m_dev5_reg_023 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[4] = dev5_mmio_hwport->m_dev5_reg_024 ^ dev5_mmio_hwport->m_dev5_reg_039;
+	}
+	if ( (dev5_reg_038 & 2) )
+	{
+		key[5] = dev5_mmio_hwport->m_dev5_reg_028 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[6] = dev5_mmio_hwport->m_dev5_reg_029 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[7] = dev5_mmio_hwport->m_dev5_reg_02A ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[8] = dev5_mmio_hwport->m_dev5_reg_02B ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[9] = dev5_mmio_hwport->m_dev5_reg_02C ^ dev5_mmio_hwport->m_dev5_reg_039;
+	}
+	if ( (dev5_reg_038 & 4) )
+	{
+		key[10] = dev5_mmio_hwport->m_dev5_reg_030 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[11] = dev5_mmio_hwport->m_dev5_reg_031 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[12] = dev5_mmio_hwport->m_dev5_reg_032 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[13] = dev5_mmio_hwport->m_dev5_reg_033 ^ dev5_mmio_hwport->m_dev5_reg_039;
+		key[14] = dev5_mmio_hwport->m_dev5_reg_034 ^ dev5_mmio_hwport->m_dev5_reg_039;
+	}
+	key[15] = dev5_reg_038 & 7;
+	vSetEventFlag(g_scmd_evfid, 1);
+	return 1;
+}
+#endif
+
+#ifdef CDVD_VARIANT_DNAS
+static int cdvdman_ncmd_sender_0C(int arg1, u32 arg2, u32 arg3)
+{
+	char ndata[7];
+
+	ndata[1] = !!arg2;
+	ndata[0] = arg1;
+	ndata[2] = !!(arg2 >> 8);
+	*(u32 *)&ndata[3] = !arg1 ? arg3 : 0;
+	return cdvdman_send_ncmd(0x0C, ndata, sizeof(ndata), 0, 0, 1) >= 0;
+}
+#endif
+
+int sceCdDecSet(u8 enable_xor, u8 enable_shift, u8 shiftval)
+{
+#ifdef CDVD_VARIANT_DNAS
+	USE_DEV5_MMIO_HWPORT();
+
+	g_cdvdman_cd36key = enable_shift | shiftval;
+	dev5_mmio_hwport->m_dev5_reg_03A = ((shiftval & 7) << 4) | ((!!enable_xor) << 1) | (!!enable_shift);
+#else
+	(void)enable_xor;
+	(void)enable_shift;
+	(void)shiftval;
+#endif
+	return 1;
+}
+
+#ifdef CDVD_VARIANT_OSD
+int sceCdOpenConfig(int block, int mode, int NumBlocks, u32 *status)
+{
+	int retval;
+#ifdef CDVD_VARIANT_XOSD
+	u32 efbits;
+#endif
+	char wdata[3];
+
+#ifdef CDVD_VARIANT_XOSD
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	{
+		return 0;
+	}
+#endif
+	DelayThread(16000);
+	*status = SCECdErNO;
+	wdata[0] = (u8)mode;
+	wdata[1] = (u8)block;
+	wdata[2] = (u8)NumBlocks;
+	retval = set_prev_command(0x40, wdata, sizeof(wdata), (char *)status, 1, 0);
+#ifdef CDVD_VARIANT_XOSD
+	if ( retval == 1 )
+#endif
+	{
+		g_cdvdman_config_numblocks = NumBlocks;
+	}
+#ifdef CDVD_VARIANT_XOSD
+	vSetEventFlag(g_scmd_evfid, 1);
+#endif
+	return retval;
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdCloseConfig(u32 *status)
+{
+	int retval;
+
+	*status = SCECdErNO;
+	DelayThread(16000);
+	retval = set_prev_command(0x43, NULL, 0, (char *)status, 1, 1);
+	g_cdvdman_config_numblocks = 0;
+	return retval;
+}
+
+static int read_config_process(char *outval, u32 *status)
+{
+	int retval;
+	char rdata[16];
+
+	DelayThread(2000);
+	retval = set_prev_command(0x41, NULL, 0, rdata, sizeof(rdata), 0);
+	*status = (u8)(rdata[14] + rdata[13] + rdata[12] + rdata[11] + rdata[10] + rdata[9] + rdata[8] + rdata[7] + rdata[6]
+								 + rdata[5] + rdata[4] + rdata[3] + rdata[2] + rdata[0] + rdata[1])
+				 != (u8)rdata[15];
+	memcpy(outval, rdata, sizeof(rdata) - 1);
+	return retval;
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdReadConfig(void *buffer, u32 *status)
+{
+	int retval;
+	u32 efbits;
+
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	{
+		return 0;
+	}
+	for ( retval = 0; retval < g_cdvdman_config_numblocks; retval += 1 )
+	{
+		if ( !read_config_process((char *)buffer + 15 * retval, status) )
+		{
+			VERBOSE_KPRINTF(1, "RC_fail Command busy\n");
+			break;
+		}
+		if ( *status )
+		{
+			VERBOSE_KPRINTF(1, "RC_fail status: 0x%02x\n", *status);
+			break;
+		}
+	}
+	vSetEventFlag(g_scmd_evfid, 1);
+	return retval;
+}
+
+static int write_config_process(const char *inval, u32 *status)
+{
+	char wdata[16];
+
+	DelayThread(2000);
+	*status = SCECdErNO;
+	memcpy(wdata, inval, 15);
+	wdata[15] = wdata[14] + wdata[13] + wdata[12] + wdata[11] + wdata[10] + wdata[9] + wdata[8] + wdata[7] + wdata[6]
+						+ wdata[5] + wdata[4] + wdata[3] + wdata[2] + wdata[0] + wdata[1];
+	return set_prev_command(0x42, wdata, sizeof(wdata), (char *)status, 1, 0);
+}
+
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdWriteConfig(const void *buffer, u32 *status)
+{
+	int retval;
+	u32 efbits;
+
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	{
+		return 0;
+	}
+	for ( retval = 0; retval < g_cdvdman_config_numblocks; retval += 1 )
+	{
+		if ( !write_config_process((char *)buffer + 15 * retval, status) )
+		{
+			VERBOSE_KPRINTF(1, "WC_fail Command busy\n");
+			break;
+		}
+		if ( *status )
+		{
+			VERBOSE_KPRINTF(1, "WC_fail status: 0x%02x\n", *status);
+			break;
+		}
+	}
+	vSetEventFlag(g_scmd_evfid, 1);
+	return retval;
+}
+
+int sceCdSetHDMode(u32 mode)
+{
+	char wdata[1];
+	char rdata[1];
+
+	wdata[0] = mode;
+	return set_prev_command(0x0C, wdata, sizeof(wdata), rdata, sizeof(rdata), 1) && !rdata[0];
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdXLEDCtl(u8 arg1, u8 arg2, u32 *param, u32 *status)
+{
+	int retval;
+	char wdata[2];
+	char rdata[2];
+
+	*param = 0;
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = arg1;
+	wdata[1] = arg2;
+	retval = set_prev_command(0x2D, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	if ( !retval )
+	{
+		return 0;
+	}
+	*status = (u8)rdata[0];
+	*param = (u8)rdata[1];
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdBuzzerCtl(u32 *status)
+{
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	return set_prev_command(0x2E, NULL, 0, (char *)status, 1, 1);
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+int sceCdResetWakeupReason(u32 *inbuf, u32 *status)
+{
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	return cdvdman_write_scmd_swap_dev5(0x2F, (char *)inbuf, 16, (char *)status, 1, 1);
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+int cdvdman_169(u32 *arg1, u32 *status)
+{
+	int i;
+	int retval;
+	char rdata[9];
+	u32 efbits;
+	char wdata[1];
+
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	if ( vPollEventFlag(g_scmd_evfid, 1, WEF_AND | WEF_CLEAR, &efbits) == KE_EVF_COND )
+	{
+		return 0;
+	}
+	memset(arg1, 0, 16);
+	if ( *status )
+	{
+		vSetEventFlag(g_scmd_evfid, 1);
+		return 1;
+	}
+	retval = 0;
+	for ( i = 0; i < 2 && !rdata[0]; i += 1 )
+	{
+		wdata[0] = i * 8;
+		retval = 0;
+		while ( !retval )
+		{
+			DelayThread(2000);
+			retval = cdvdman_write_scmd_swap_dev5(0x30, wdata, sizeof(wdata), rdata, sizeof(rdata), 0);
+			memcpy(&arg1[i * 2], &rdata[1], sizeof(rdata) - 1);
+			*status = rdata[0];
+		}
+	}
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdXBSPowerCtl(u8 arg1, u8 arg2, u32 *param, u32 *status)
+{
+	int retval;
+	char wdata[2];
+	char rdata[2];
+
+	*param = 0;
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = arg1;
+	wdata[1] = arg2;
+	retval = set_prev_command(0x2C, wdata, sizeof(wdata), rdata, sizeof(rdata), 1);
+	if ( !retval )
+	{
+		return 0;
+	}
+	*status = (u8)rdata[0];
+	*param = (u8)rdata[1];
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdSetMediumRemoval(u8 wanted_val, u32 *status)
+{
+	int retval;
+	int saved_medium_removal_state;
+	char wdata[1];
+	int state;
+
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	CpuSuspendIntr(&state);
+	saved_medium_removal_state = g_cdvdman_istruct.m_medium_removal_state;
+	g_cdvdman_istruct.m_medium_removal_state = (u8)wanted_val;
+	wdata[0] = wanted_val;
+	retval = set_prev_command(0x31, wdata, sizeof(wdata), (char *)status, 1, 1);
+	if ( !retval || *status )
+	{
+		g_cdvdman_istruct.m_medium_removal_state = saved_medium_removal_state;
+	}
+	CpuResumeIntr(state);
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdGetMediumRemoval(u32 *param, u32 *status)
+{
+	int retval;
+	char rdata[2];
+
+	*param = 0;
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x32, NULL, 0, rdata, sizeof(rdata), 1);
+	if ( !retval )
+	{
+		return 0;
+	}
+	*status = (u8)rdata[0];
+	*param = (u8)rdata[1];
+	if ( !rdata[0] )
+	{
+		g_cdvdman_istruct.m_medium_removal_state = *param;
+	}
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+// cppcheck-suppress funcArgNamesDifferent
+int sceCdXDVRPReset(u8 arg1, u32 *status)
+{
+	char wdata[1];
+
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	wdata[0] = arg1;
+	return set_prev_command(0x33, wdata, sizeof(wdata), (char *)status, 1, 1);
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+static int sc_ffffffd8(u32 *status)
+{
+	int retval;
+
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x34, NULL, 0, (char *)status, 1, 1);
+	if ( !retval )
+	{
+		return 0;
+	}
+	g_cdvdman_istruct.m_atapi_disk_ejected = 0;
+	return retval;
+}
+#endif
+
+#ifdef CDVD_VARIANT_XOSD
+#ifdef DEAD_CODE
+int cdvdman_scmd_sender_35(u32 *param, u32 *status)
+{
+	int retval;
+	char rdata[2];
+
+	*param = 0;
+	if ( !g_cdvdman_minver_50600 )
+	{
+		*status = 256;
+		return 1;
+	}
+	*status = SCECdErNO;
+	retval = set_prev_command(0x35, NULL, 0, rdata, sizeof(rdata), 1);
+	if ( !retval )
+	{
+		return 0;
+	}
+	*status = (u8)rdata[0];
+	*param = (u8)rdata[1];
+	return retval;
+}
+#endif
+#endif
diff --git a/iop/cdvd/cdvdstm/src/cdvdstm.c b/iop/cdvd/cdvdstm/src/cdvdstm.c
index 485c1361132..9abcd67a4d1 100644
--- a/iop/cdvd/cdvdstm/src/cdvdstm.c
+++ b/iop/cdvd/cdvdstm/src/cdvdstm.c
@@ -20,8 +20,8 @@ IRX_ID("cdvd_st_driver", 2, 2);
 
 extern struct irx_export_table _exp_cdvdstm;
 
-int cdvdstm_dummyentry();
-int cdvdstm_termcall();
+extern int cdvdstm_dummyentry(void);
+extern int cdvdstm_termcall(void);
 static unsigned int iop_stream_handler(
 	unsigned int posszarg1, unsigned int posszarg2, void *buffer, int cmdid, const sceCdRMode *rmode, int *error_ptr);
 static unsigned int iop_stream_intr_cb(void *userdata);
@@ -33,7 +33,7 @@ static void ee_stream_handler_normal(cdrom_stm_devctl_t *instruct, int inbuf_len
 static unsigned int ee_stream_intr_cb_normal(void *userdata);
 static void ee_stream_handler_cdda(cdrom_stm_devctl_t *instruct, int inbuf_len, int *outres_ptr);
 static unsigned int ee_stream_intr_cb_cdda(void *userdata);
-unsigned int optimized_memcpy(char *dst, const char *src, unsigned int n);
+extern unsigned int optimized_memcpy(char *dst, const char *src, unsigned int n);
 
 static void iop_stream_intr_cb_thunk(int userdata)
 {
@@ -64,33 +64,33 @@ static int g_cdvdstm_retrycnt_iop = 0;
 IOMANX_RETURN_VALUE_IMPL(EIO);
 
 static iop_device_ops_t g_cdrom_stm_dev_ops = {
-	&cdrom_stm_init, // init,
-	&cdrom_stm_deinit, // deinit,
-	IOMANX_RETURN_VALUE(EIO), // format,
-	IOMANX_RETURN_VALUE(EIO), // open,
-	IOMANX_RETURN_VALUE(EIO), // close,
-	IOMANX_RETURN_VALUE(EIO), // read,
-	IOMANX_RETURN_VALUE(EIO), // write,
-	IOMANX_RETURN_VALUE(EIO), // lseek,
-	IOMANX_RETURN_VALUE(EIO), // ioctl,
-	IOMANX_RETURN_VALUE(EIO), // remove,
-	IOMANX_RETURN_VALUE(EIO), // mkdir,
-	IOMANX_RETURN_VALUE(EIO), // rmdir,
-	IOMANX_RETURN_VALUE(EIO), // dopen,
-	IOMANX_RETURN_VALUE(EIO), // dclose,
-	IOMANX_RETURN_VALUE(EIO), // dread,
-	IOMANX_RETURN_VALUE(EIO), // getstat,
-	IOMANX_RETURN_VALUE(EIO), // chstat,
-	IOMANX_RETURN_VALUE(EIO), // rename,
-	IOMANX_RETURN_VALUE(EIO), // chdir,
-	IOMANX_RETURN_VALUE(EIO), // sync,
-	IOMANX_RETURN_VALUE(EIO), // mount,
-	IOMANX_RETURN_VALUE(EIO), // umount,
-	IOMANX_RETURN_VALUE_S64(EIO), // lseek64,
+	&cdrom_stm_init,               // init,
+	&cdrom_stm_deinit,             // deinit,
+	IOMANX_RETURN_VALUE(EIO),      // format,
+	IOMANX_RETURN_VALUE(EIO),      // open,
+	IOMANX_RETURN_VALUE(EIO),      // close,
+	IOMANX_RETURN_VALUE(EIO),      // read,
+	IOMANX_RETURN_VALUE(EIO),      // write,
+	IOMANX_RETURN_VALUE(EIO),      // lseek,
+	IOMANX_RETURN_VALUE(EIO),      // ioctl,
+	IOMANX_RETURN_VALUE(EIO),      // remove,
+	IOMANX_RETURN_VALUE(EIO),      // mkdir,
+	IOMANX_RETURN_VALUE(EIO),      // rmdir,
+	IOMANX_RETURN_VALUE(EIO),      // dopen,
+	IOMANX_RETURN_VALUE(EIO),      // dclose,
+	IOMANX_RETURN_VALUE(EIO),      // dread,
+	IOMANX_RETURN_VALUE(EIO),      // getstat,
+	IOMANX_RETURN_VALUE(EIO),      // chstat,
+	IOMANX_RETURN_VALUE(EIO),      // rename,
+	IOMANX_RETURN_VALUE(EIO),      // chdir,
+	IOMANX_RETURN_VALUE(EIO),      // sync,
+	IOMANX_RETURN_VALUE(EIO),      // mount,
+	IOMANX_RETURN_VALUE(EIO),      // umount,
+	IOMANX_RETURN_VALUE_S64(EIO),  // lseek64,
 	&cdrom_stm_devctl,
-	IOMANX_RETURN_VALUE(EIO), // symlink
-	IOMANX_RETURN_VALUE(EIO), // readlink
-	IOMANX_RETURN_VALUE(EIO), // ioctl2
+	IOMANX_RETURN_VALUE(EIO),  // symlink
+	IOMANX_RETURN_VALUE(EIO),  // readlink
+	IOMANX_RETURN_VALUE(EIO),  // ioctl2
 };
 static iop_device_t g_cdrom_stm_dev = {"cdrom_stm", IOP_DT_FSEXT | IOP_DT_FS, 1, "CD-ROM_STM ", &g_cdrom_stm_dev_ops};
 static int g_cdvdstm_last_error_for_ee = 0;
@@ -133,23 +133,23 @@ static int vCancelAlarm(unsigned int (*alarm_cb)(void *), void *arg)
 	return (QueryIntrContext() ? iCancelAlarm : CancelAlarm)(alarm_cb, arg);
 }
 
-static int vSetEventFlag()
+static int vSetEventFlag(void)
 {
 	return (QueryIntrContext() ? iSetEventFlag : SetEventFlag)(g_cdvdman_intr_efid, 8);
 }
 
-static int vClearEventFlag()
+static int vClearEventFlag(void)
 {
 	return (QueryIntrContext() ? iClearEventFlag : ClearEventFlag)(g_cdvdman_intr_efid, ~8);
 }
 
-int cdvdstm_dummyentry()
+int cdvdstm_dummyentry(void)
 {
 	VERBOSE_PRINTF(1, "Dummy Entry Called\n");
 	return 0;
 }
 
-int cdvdstm_termcall()
+int cdvdstm_termcall(void)
 {
 	cdrom_stm_devctl_t instruct;
 	int outres;
@@ -440,7 +440,11 @@ static unsigned int iop_stream_intr_cb(void *userdata)
 	sceCdSC(0xFFFFFFFF, &last_error);
 	if ( !last_error )
 	{
+#ifdef CDVD_VARIANT_XOSD
+		switch ( sceCdSC(0xFFFFFFDA, &scres_unused) )
+#else
 		switch ( sceCdGetDiskType() )
+#endif
 		{
 			case SCECdPSCD:
 			case SCECdPSCDDA:
@@ -654,6 +658,7 @@ static int cdrom_stm_devctl(
 			ee_stream_handler_cdda(instruct, inbuf_len, outres_ptr);
 			break;
 		default:
+			// The following printf was removed for ioprp300x
 			PRINTF("Un-support devctl %08x\n", cmd);
 			retres = -EIO;
 			break;
@@ -710,6 +715,23 @@ int _start(int ac, char *av[], void *startaddr, ModuleInfo_t *mi)
 #endif
 }
 
+static int vsceSifDmaStat(int dmat)
+{
+#ifdef CDVD_VARIANT_XOSD
+	int st;
+	int state;
+
+	if ( QueryIntrContext() )
+		return sceSifDmaStat(dmat);
+	CpuSuspendIntr(&state);
+	st = sceSifDmaStat(dmat);
+	CpuResumeIntr(state);
+	return st;
+#else
+	return sceSifDmaStat(dmat);
+#endif
+}
+
 static int stm_ee_read_timeout_alarm_cb(const iop_sys_clock_t *sys_clock)
 {
 	int read_timeout;
@@ -939,7 +961,7 @@ static void ee_stream_handler_normal(cdrom_stm_devctl_t *instruct, int inbuf_len
 				DelayThread(500);
 			}
 			g_cdvdstm_bankoffs_ee += posszarg2_bytes_clamped;
-			while ( sceSifDmaStat(dmat1) >= 0 )
+			while ( vsceSifDmaStat(dmat1) >= 0 )
 				;
 		}
 		if ( (unsigned int)g_cdvdstm_bankoffs_ee >= (unsigned int)g_cdvdstm_chunksz2 )
@@ -1003,7 +1025,11 @@ static unsigned int ee_stream_intr_cb_normal(void *userdata)
 	sceCdSC(0xFFFFFFFF, &g_cdvdstm_last_error_for_ee);
 	if ( !g_cdvdstm_last_error_for_ee )
 	{
+#ifdef CDVD_VARIANT_XOSD
+		switch ( sceCdSC(0xFFFFFFDA, &scres_unused) )
+#else
 		switch ( sceCdGetDiskType() )
+#endif
 		{
 			case SCECdPSCD:
 			case SCECdPSCDDA:
@@ -1401,7 +1427,7 @@ static void ee_stream_handler_cdda(cdrom_stm_devctl_t *instruct, int inbuf_len,
 				DelayThread(500);
 			}
 			g_cdvdstm_bankoffs_ee += posszarg2_bytes_clamped;
-			while ( sceSifDmaStat(dmat2) >= 0 )
+			while ( vsceSifDmaStat(dmat2) >= 0 )
 				;
 		}
 		if ( (unsigned int)g_cdvdstm_bankoffs_ee >= (unsigned int)g_cdvdstm_chunksz2 )
@@ -1468,7 +1494,11 @@ static unsigned int ee_stream_intr_cb_cdda(void *userdata)
 	sceCdSC(0xFFFFFFFF, &g_cdvdstm_last_error_for_ee);
 	if ( !g_cdvdstm_last_error_for_ee )
 	{
+#ifdef CDVD_VARIANT_XOSD
+		switch ( sceCdSC(0xFFFFFFDA, &scres_unused) )
+#else
 		switch ( sceCdGetDiskType() )
+#endif
 		{
 			case SCECdPSCDDA:
 			case SCECdPS2CDDA: