예제 #1
0
파일: stm.c 프로젝트: comex/libogc
s32 STM_ShutdownToIdle()
{
	int res;

	_viReg[1] = 0;
	if(__stm_initialized==0) {
#ifdef DEBUG_STM
		printf("STM notinited\n");
#endif
		return STM_ENOTINIT;
	}
	switch(SYS_GetHollywoodRevision()) {
		case 0:
		case 1:
		case 2:
			__stm_immbufin[0] = 0xFCA08280;
		default:
			__stm_immbufin[0] = 0xFCE082C0;
	}
	res= IOS_Ioctl(__stm_imm_fd,IOCTL_STM_IDLE,__stm_immbufin,0x20,__stm_immbufout,0x20);
	if(res<0) {
#ifdef DEBUG_STM
		printf("STM IDLE failed: %d\n",res);
#endif
	}
	return res;
}
예제 #2
0
/* Register a USB class driver */
int UhsClassDrvReg(int uhs_handle, UhsInterfaceFilter *filter, void *context, int (*cb)(void *ctx, UhsInterfaceProfile *profile))
{
	/* Symbol loading */
	unsigned int coreinit_handle;
	OSDynLoad_Acquire("coreinit.rpl", &coreinit_handle);
	void* (*memcpy)(void *dest, void *src, uint32_t length);
	int (*IOS_Ioctl)(int fd, int request, void *inbuf, int inlen, void *outbuf, int outlen);
	OSDynLoad_FindExport(coreinit_handle, false, "memcpy", &memcpy);
	OSDynLoad_FindExport(coreinit_handle, false, "IOS_Ioctl", &IOS_Ioctl);

	/* Allocate and fill in the request buffer */
	uint32_t reqbuf[6];
	reqbuf[0] = (uint32_t)context;
	reqbuf[1] = (uint32_t)cb;
	memcpy(&reqbuf[2], filter, sizeof(UhsInterfaceFilter));

	/* Perform the ioctl() request */
	int ret = -1;
	IOS_Ioctl(uhs_handle, 0x01, reqbuf, 0x18, &ret, 4);

	/* Set up the callback to be executed */
	wait_uhs_event(uhs_handle);

	return ret;
}
예제 #3
0
MCPError
MCP_GetTitleId(IOSHandle handle,
               be_val<uint64_t> *titleId)
{
   auto result = MCPError::OK;
   auto output = internal::mcpAllocateMessage(sizeof(MCPResponseGetTitleId));

   if (!output) {
      return MCPError::AllocError;
   }

   auto iosError = IOS_Ioctl(handle,
                             MCPCommand::GetTitleId,
                             nullptr,
                             0,
                             output,
                             sizeof(MCPResponseGetTitleId));

   result = internal::mcpDecodeIosErrorToMcpError(iosError);

   if (result >= 0) {
      auto response = reinterpret_cast<MCPResponseGetTitleId *>(output);
      *titleId = response->titleId;
   }

   internal::mcpFreeMessage(output);
   return result;
}
예제 #4
0
s32 Nand_Enable(nandDevice *dev)
{
	s32 fd, ret;

	/* Open /dev/fs */
	fd = IOS_Open("/dev/fs", 0);
	if (fd < 0)
		return fd;

	memset(inbuf, 0, sizeof(inbuf));

	/* Set input buffer */
	if (IOS_GetRevision() >= 20)
	{
		// New method, fully enable full emulation
		inbuf[0] = dev->mode | 0x100;
	} else
	{
		// Old method
		inbuf[0] = dev->mode;
	}

	/* Enable NAND emulator */
	ret = IOS_Ioctl(fd, 100, inbuf, sizeof(inbuf), NULL, 0);

	/* Close /dev/fs */
	IOS_Close(fd);

	return ret;
} 
예제 #5
0
IOSError
mcpSearchTitleList(IOSHandle handle,
                   MCPTitleListType *searchTitle,
                   MCPTitleListSearchFlags searchFlags,
                   MCPTitleListType *titleList,
                   uint32_t titleListLength)
{
   auto message = mcpAllocateMessage(sizeof(MCPRequestSearchTitleList));

   if (!message) {
      return static_cast<IOSError>(MCPError::AllocError);
   }

   auto request = reinterpret_cast<MCPRequestSearchTitleList *>(message);
   request->searchTitle = *searchTitle;
   request->searchFlags = searchFlags;

   auto iosError = IOS_Ioctl(handle,
                             MCPCommand::SearchTitleList,
                             request,
                             sizeof(MCPRequestSearchTitleList),
                             titleList,
                             titleListLength * sizeof(MCPTitleListType));

   mcpFreeMessage(message);
   return iosError;
}
예제 #6
0
s32 CheckDisk(void *id)
	{
	const char di_fs[] ATTRIBUTE_ALIGN(32) = "/dev/di";
	s32 di_fd = -1;
	u32 inbuf[8]  ATTRIBUTE_ALIGN(32);
	u32 outbuf[8] ATTRIBUTE_ALIGN(32);	
	
	/* Open "/dev/di" */
	di_fd = IOS_Open(di_fs, 0);
	if (di_fd < 0) return di_fd; // error

	/* Reset drive */
	memset(inbuf, 0, sizeof(inbuf));
	inbuf[0] = IOCTL_DI_RESET << 24;
	inbuf[1] = 1;

	s32 ret = IOS_Ioctl(di_fd, IOCTL_DI_RESET, inbuf, sizeof(inbuf), outbuf, sizeof(outbuf));
	if (ret < 0) 
		{
		IOS_Close(di_fd);
		return ret;
		}

	/* Read disc ID */
	memset(inbuf, 0, sizeof(inbuf));
	inbuf[0] = IOCTL_DI_READID << 24;
	ret = IOS_Ioctl(di_fd, IOCTL_DI_READID, inbuf, sizeof(inbuf), outbuf, sizeof(outbuf));
	if (ret < 0) return ret;
	if (ret == 1 && id)
		memcpy(id, outbuf, sizeof(dvddiskid));
		
	/* Stop motor */
	memset(inbuf, 0, sizeof(inbuf));
	inbuf[0] = IOCTL_DI_STOPMOTOR << 24;
	IOS_Ioctl(di_fd, IOCTL_DI_STOPMOTOR, inbuf, sizeof(inbuf), outbuf, sizeof(outbuf));
	IOS_Close(di_fd);

	if (ret != 1)
		{
		grlib_menu (0, "Sorry, no disc is detected in your WII", " OK ");
		}
	return ret;
	}
예제 #7
0
파일: uhs.c 프로젝트: Gskartwii/libwiiu
/* Determine which USB device interfaces are plugged in and available */
int UhsQueryInterfaces(int uhs_handle, UhsInterfaceFilter *filter, UhsInterfaceProfile *profiles, int max_profiles)
{
	/* Symbol loading */
	unsigned int coreinit_handle;
	OSDynLoad_Acquire("coreinit.rpl", &coreinit_handle);
	int (*IOS_Ioctl)(int fd, int request, void *inbuf, int inlen, void *outbuf, int outlen);
	OSDynLoad_FindExport(coreinit_handle, false, "IOS_Ioctl", &IOS_Ioctl);

	/* Perform the ioctl() request */
	return IOS_Ioctl(uhs_handle, 0x11, filter, 0x10, profiles, max_profiles * 0x16c);
}
예제 #8
0
파일: DI.c 프로젝트: BhaaLseN/sneek
s32 DVDEjectDisc( void )
{
	s32 fd = IOS_Open("/dev/di", 0 );
	if( fd < 0 )
		return fd;

	s32 r = IOS_Ioctl( fd, DVD_EJECT_DISC, NULL, 0, NULL, 0 );

	IOS_Close( fd );

	return r;
}
예제 #9
0
파일: DI.c 프로젝트: BhaaLseN/sneek
s32 DVDLowPrepareCoverRegister( u32 *Cover )
{
	s32 fd = IOS_Open("/dev/di", 0 );
	if( fd < 0 )
		return fd;

	s32 r = IOS_Ioctl( fd, 0x7A, NULL, 0, Cover, sizeof(u32) );

	IOS_Close( fd );

	return r;
}
예제 #10
0
파일: DI.c 프로젝트: BhaaLseN/sneek
s32 DVDGetGameCount( u32 *Count )
{
	s32 fd = IOS_Open("/dev/di", 0 );
	if( fd < 0 )
		return fd;

	s32 r = IOS_Ioctl( fd, DVD_GET_GAMECOUNT, NULL, 0, Count, sizeof(u32) );

	IOS_Close( fd );

	return r;
}
예제 #11
0
파일: DI.c 프로젝트: BhaaLseN/sneek
s32 DVDConnected( void )
{
	s32 fd = IOS_Open("/dev/di", 0 );
	if( fd < 0 )
		return fd;

	s32 r = IOS_Ioctl( fd, DVD_CONNECTED, NULL, 0, NULL, 0);
	
	IOS_Close( fd );

	return r;
}
예제 #12
0
파일: DI.c 프로젝트: BhaaLseN/sneek
s32 DVDInsertDisc( void )
{
	s32 fd = IOS_Open("/dev/di", 0 );
	if( fd < 0 )
		return fd;

	s32 r = IOS_Ioctl( fd, DVD_INSERT_DISC, NULL, 0, NULL, 0 );

	IOS_Close( fd );

	return r;
}
예제 #13
0
s32 WDVD_ReadDiskId(void *id)
{
	memset(inbuf, 0, sizeof(inbuf));

	/* Read disc ID */
	inbuf[0] = IOCTL_DI_READID << 24;

	s32 ret = IOS_Ioctl(di_fd, IOCTL_DI_READID, inbuf, sizeof(inbuf), outbuf, sizeof(outbuf));
	if(ret < 0)
		return ret;
	memcpy(id, outbuf, sizeof(dvddiskid));
	return (ret == 1) ? 0 : -ret;
}
예제 #14
0
s32 WDVD_Reset(void)
{
	memset(inbuf, 0, sizeof(inbuf));

	/* Reset drive */
	inbuf[0] = IOCTL_DI_RESET << 24;
	inbuf[1] = 1;

	s32 ret = IOS_Ioctl(di_fd, IOCTL_DI_RESET, inbuf, sizeof(inbuf), outbuf, sizeof(outbuf));
	if(ret < 0)
		return ret;
	return (ret == 1) ? 0 : -ret;
}
예제 #15
0
s32 WDVD_Seek(u32 offset)
{
	memset(inbuf, 0, sizeof(inbuf));

	/* Drive seek */
	inbuf[0] = IOCTL_DI_SEEK << 24;
	inbuf[1] = offset;

	s32 ret = IOS_Ioctl(di_fd, IOCTL_DI_SEEK, inbuf, sizeof(inbuf), outbuf, sizeof(outbuf));
	if(ret < 0)
		return ret;
	return (ret == 1) ? 0 : -ret;
}
예제 #16
0
s32 WDVD_Read(void *buf, u32 len, u32 offset)
{
	memset(inbuf, 0, sizeof(inbuf));

	/* Disc read */
	inbuf[0] = IOCTL_DI_READ << 24;
	inbuf[1] = len;
	inbuf[2] = offset;

	s32 ret = IOS_Ioctl(di_fd, IOCTL_DI_READ, inbuf, sizeof(inbuf), buf, len);
	if(ret < 0)
		return ret;
	return (ret == 1) ? 0 : -ret;
}
예제 #17
0
파일: stm.c 프로젝트: comex/libogc
s32 __STM_ReleaseEventHook()
{
	s32 ret;

	if(__stm_initialized==0) return STM_ENOTINIT;
	if(__stm_ehregistered==0) return STM_ENOHANDLER;

	__stm_ehclear = 1;
	
	ret = IOS_Ioctl(__stm_imm_fd,IOCTL_STM_RELEASE_EH,__stm_immbufin,0x20,__stm_immbufout,0x20);
	if(ret>=0) __stm_ehregistered = 0;

	return ret;
}
예제 #18
0
MCPError
MCP_TitleCount(IOSHandle handle)
{
   auto result = IOS_Ioctl(handle,
                           MCPCommand::TitleCount,
                           nullptr, 0,
                           nullptr, 0);

   if (result < 0) {
      return internal::mcpDecodeIosErrorToMcpError(result);
   }

   return static_cast<MCPError>(result);
}
예제 #19
0
int DIP::Close_Partition() 
{
	Lock();

	Command[0] = Ioctl::DI_ClosePartition << 24;

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_ClosePartition, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_ClosePartition)";

	return ((Ret == 1)? 0 : -Ret);
}
예제 #20
0
int DIP::Reset()
{
	Command[0] = Ioctl::DI_Reset << 24;
	Command[1] = 1;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_Reset, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_Reset)";

	return ((Ret == 1) ? 0 : -Ret);
}
예제 #21
0
int DIP::Wait_CoverClose()
{
	memset(Command, 0, 0x20);
	Command[0] = Ioctl::DI_WaitCoverClose << 24;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_WaitCoverClose, Command, 0x20, Output, 0x20);
	
	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_WaitCoverClose)";

	return ((Ret == 1) ? 0 : -Ret);
}
예제 #22
0
s32 WDVD_Read(void *buf, u32 len, u64 offset) {
	s32 ret;

	memset(inbuf, 0, sizeof(inbuf));

	inbuf[0] = IOCTL_DI_READ << 24;
	inbuf[1] = len;
	inbuf[2] = (u32)(offset >> 2);

	ret = IOS_Ioctl(di_fd, IOCTL_DI_READ, inbuf, sizeof(inbuf), buf, len);
	if (ret < 0)
		return ret;

	return (ret == 1) ? 0 : -ret;
}
예제 #23
0
int DIP::Stop_Motor()
{
	Command[0] = Ioctl::DI_StopMotor << 24;
	Command[1] = 0;		// Set this to 1 to eject the disc
	Command[2] = 0;		// This will temporarily kill the drive if set!!!

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_StopMotor, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_StopMotor)";

	return ((Ret == 1) ? 0 : -Ret);
}
예제 #24
0
int DIP::Get_OffsetBase(unsigned int* Base)
{
	memset(Command, 0, 0x20);
	Command[0] = Ioctl::DI_GetOffsetBase << 24;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_GetOffsetBase, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_GetOffsetBase)";
	if (Ret == 1) *Base = *((unsigned int*)Output);
	
	return ((Ret == 1) ? 0 : -Ret);
}
예제 #25
0
int DIP::Enable_DVD()
{
	memset(Command, 0, 0x20);
	Command[0] = Ioctl::DI_EnableDVD << 24;
	Command[1] = 1;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_EnableDVD, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_EnableDVD)";

	return ((Ret == 1) ? 0 : -Ret);
}
예제 #26
0
int DIP::Verify_Cover(bool *Inserted)
{
	memset(Command, 0, 0x20);
	Command[0] = Ioctl::DI_VerifyCover << 24;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_VerifyCover, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_VerifyCover)";
	if (Ret == 1) *Inserted = !((bool)*Output);

	return ((Ret == 1) ? 0 : -Ret);
}
예제 #27
0
s32 WDVD_ClosePartition(void)
{
	s32 ret;

//	partitionOpen = false;

	memset(inbuf, 0, sizeof(inbuf));

	inbuf[0] = IOCTL_DI_CLOSEPART << 24;

	ret = IOS_Ioctl(di_fd, IOCTL_DI_CLOSEPART, inbuf, sizeof(inbuf), NULL, 0);
	if (ret < 0)
		return ret;

	return (ret == 1) ? 0 : -ret;
}
예제 #28
0
/****************************************************************************
 * Get network IP
 ***************************************************************************/
bool ShutdownWC24() {
    bool onlinefix = IsNetworkInit();
    if (onlinefix) {
        s32 kd_fd, ret;
        STACK_ALIGN(u8, kd_buf, 0x20, 32);

        kd_fd = IOS_Open("/dev/net/kd/request", 0);
        if (kd_fd >= 0) {
            ret = IOS_Ioctl(kd_fd, 7, NULL, 0, kd_buf, 0x20);
            if (ret >= 0)
                onlinefix = false; // fixed no IOS reload needed
            IOS_Close(kd_fd);
        }
    }
    return onlinefix;
}
예제 #29
0
int DIP::Read_DiscID(dvddiskid* Disc_ID)
{
	if (!Disc_ID) throw "Null Disc_ID pointer";
	
	Command[0] = Ioctl::DI_ReadID << 24;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_ReadID, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_ReadID)";
	memcpy(Disc_ID, Output, 0x20);
	
	return ((Ret == 1) ? 0 : -Ret);
}
예제 #30
0
int DIP::Inquiry(void* Drive_ID)
{
	if (!Drive_ID) throw "Null DriveID pointer";

	Command[0] = Ioctl::DI_Inquiry << 24;

	Lock();

	int Ret = IOS_Ioctl(Device_Handle, Ioctl::DI_Inquiry, Command, 0x20, Output, 0x20);

	Unlock();

	if (Ret == 2) throw "Ioctl error (DI_Inquiry)";
	memcpy(Drive_ID, Output, 8);

	return ((Ret == 1) ? 0 : -Ret);
}