545 lines
16 KiB
C++
545 lines
16 KiB
C++
// Copyright (C) 2003-2008 Dolphin Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
|
|
#include "pluginspecs_wiimote.h"
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include "Common.h"
|
|
#include "wiimote_hid.h"
|
|
#include "EmuSubroutines.h"
|
|
#include "EmuDefinitions.h"
|
|
#include "Encryption.h" // for extension encryption
|
|
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
|
|
#include "Config.h" // for g_Config
|
|
|
|
extern SWiimoteInitialize g_WiimoteInitialize;
|
|
//extern void __Log(int log, const char *format, ...);
|
|
//extern void __Log(int log, int v, const char *format, ...);
|
|
|
|
|
|
namespace WiiMoteEmu
|
|
{
|
|
|
|
//******************************************************************************
|
|
// Subroutines
|
|
//******************************************************************************
|
|
|
|
|
|
//wm_request_status global_struct;
|
|
//extern wm_request_status global_struct;
|
|
|
|
|
|
|
|
// ===================================================
|
|
/* Here we process the Output Reports that the Wii sends. Our response will be an Input Report
|
|
back to the Wii. Input and Output is from the Wii's perspective, Output means data to
|
|
the Wiimote (from the Wii), Input means data from the Wiimote. */
|
|
// ----------------
|
|
void HidOutputReport(u16 _channelID, wm_report* sr) {
|
|
LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
|
|
|
|
LOGV(WII_IPC_WIIMOTE, 0, "HidOutputReport(0x%02x)", sr->channel);
|
|
|
|
switch(sr->channel)
|
|
{
|
|
case 0x10:
|
|
LOGV(WII_IPC_WIIMOTE, 0, "HidOutputReport: unknown sr->channel 0x10");
|
|
break;
|
|
case WM_LEDS: // 0x11
|
|
WmLeds(_channelID, (wm_leds*)sr->data);
|
|
break;
|
|
case WM_DATA_REPORTING: // 0x12
|
|
WmDataReporting(_channelID, (wm_data_reporting*)sr->data);
|
|
break;
|
|
case WM_REQUEST_STATUS: // 0x15
|
|
//global_struct = (wm_request_status*)sr->data;
|
|
WmRequestStatus(_channelID, (wm_request_status*)sr->data);
|
|
break;
|
|
case WM_READ_DATA: // 0x17
|
|
WmReadData(_channelID, (wm_read_data*)sr->data);
|
|
break;
|
|
case WM_IR_PIXEL_CLOCK: // 0x13
|
|
case WM_IR_LOGIC: // 0x1a
|
|
LOGV(WII_IPC_WIIMOTE, 0, " IR Enable 0x%02x 0x%02x", sr->channel, sr->data[0]);
|
|
break;
|
|
case WM_WRITE_DATA: // 0x16
|
|
WmWriteData(_channelID, (wm_write_data*)sr->data);
|
|
break;
|
|
case WM_SPEAKER_ENABLE:
|
|
LOGV(WII_IPC_WIIMOTE, 1, " WM Speaker Enable 0x%02x 0x%02x", sr->channel, sr->data[0]);
|
|
break;
|
|
case WM_SPEAKER_MUTE:
|
|
LOGV(WII_IPC_WIIMOTE, 1, " WM Mute Enable 0x%02x 0x%02x", sr->channel, sr->data[0]);
|
|
break;
|
|
default:
|
|
PanicAlert("HidOutputReport: Unknown channel 0x%02x", sr->channel);
|
|
return;
|
|
}
|
|
LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
|
|
}
|
|
|
|
|
|
// ===================================================
|
|
/* LED (blue lights) report. */
|
|
// ----------------
|
|
void WmLeds(u16 _channelID, wm_leds* leds) {
|
|
LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
|
|
|
|
LOG(WII_IPC_WIIMOTE, " Set LEDs");
|
|
LOG(WII_IPC_WIIMOTE, " Leds: %x", leds->leds);
|
|
LOG(WII_IPC_WIIMOTE, " Rumble: %x", leds->rumble);
|
|
|
|
g_Leds = leds->leds;
|
|
LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
|
|
}
|
|
|
|
|
|
void WmSendAck(u16 _channelID, u8 _reportID)
|
|
{
|
|
u8 DataFrame[1024];
|
|
|
|
u32 Offset = 0;
|
|
|
|
// header
|
|
hid_packet* pHidHeader = (hid_packet*)(DataFrame + Offset);
|
|
pHidHeader->type = HID_TYPE_DATA;
|
|
pHidHeader->param = HID_PARAM_INPUT;
|
|
Offset += sizeof(hid_packet);
|
|
|
|
wm_acknowledge* pData = (wm_acknowledge*)(DataFrame + Offset);
|
|
pData->Channel = WM_WRITE_DATA_REPLY;
|
|
pData->unk0 = 0;
|
|
pData->unk1 = 0;
|
|
pData->reportID = _reportID;
|
|
pData->errorID = 0;
|
|
Offset += sizeof(wm_acknowledge);
|
|
|
|
|
|
LOGV(WII_IPC_WIIMOTE, 2, " WMSendAck()");
|
|
|
|
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
|
|
}
|
|
|
|
|
|
// ===================================================
|
|
/* Read data from Wiimote and Extensions registers. */
|
|
// ----------------
|
|
void WmReadData(u16 _channelID, wm_read_data* rd)
|
|
{
|
|
LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
|
|
u32 address = convert24bit(rd->address);
|
|
u16 size = convert16bit(rd->size);
|
|
LOG(WII_IPC_WIIMOTE, " Read data");
|
|
LOG(WII_IPC_WIIMOTE, " Address space: %x", rd->space);
|
|
LOG(WII_IPC_WIIMOTE, " Address: 0x%06x", address);
|
|
LOG(WII_IPC_WIIMOTE, " Size: 0x%04x", size);
|
|
LOG(WII_IPC_WIIMOTE, " Rumble: %x", rd->rumble);
|
|
|
|
if(rd->space == 0)
|
|
{
|
|
if (address + size > WIIMOTE_EEPROM_SIZE)
|
|
{
|
|
PanicAlert("WmReadData: address + size out of bounds!");
|
|
return;
|
|
}
|
|
SendReadDataReply(_channelID, g_Eeprom+address, address, (u8)size);
|
|
}
|
|
else if(rd->space == WM_SPACE_REGS1 || rd->space == WM_SPACE_REGS2)
|
|
{
|
|
u8* block;
|
|
u32 blockSize;
|
|
switch((address >> 16) & 0xFE)
|
|
{
|
|
/**/ case 0xA2:
|
|
block = g_RegSpeaker;
|
|
blockSize = WIIMOTE_REG_SPEAKER_SIZE;
|
|
LOGV(WII_IPC_WIIMOTE, 0, "WmReadData: 0xB0 g_RegSpeaker");
|
|
break;
|
|
case 0xA4:
|
|
block = g_RegExt;
|
|
blockSize = WIIMOTE_REG_EXT_SIZE;
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xA4: Read ExtReg ****************************");
|
|
//wprintf("WmReadData\n"); ReadExt();
|
|
break;
|
|
/**/ case 0xB0:
|
|
block = g_RegIr;
|
|
blockSize = WIIMOTE_REG_IR_SIZE;
|
|
//PanicAlert("WmReadData: 0xB0 g_RegIr");
|
|
LOGV(WII_IPC_WIIMOTE, 0, "WmReadData: 0xB0 g_RegIr");
|
|
break;
|
|
default:
|
|
PanicAlert("WmWriteData: bad register block!");
|
|
return;
|
|
}
|
|
|
|
|
|
// -----------------------------------------
|
|
// Encrypt data that is read from the Wiimote Extension Register
|
|
// -------------
|
|
if(((address >> 16) & 0xfe) == 0xa4)
|
|
{
|
|
wprintf("\n\nWmReadData Address: %08x Offset: %08x Size: %i byte\n",
|
|
address, address & 0xffff, (u8)size);
|
|
|
|
// Debugging
|
|
u32 offset = address & 0xffff;
|
|
wprintf("Unencrypted data:\n");
|
|
for (int i = 0; i < (u8)size; i++)
|
|
{
|
|
wprintf("%02x ", g_RegExt[i + offset]);
|
|
if((i + 1) % 20 == 0) wprintf("\n");
|
|
}
|
|
|
|
// Check if encrypted reads is on
|
|
if(g_RegExt[0xf0] == 0xaa)
|
|
{
|
|
// Copy g_RegExt to g_RegExtTmp
|
|
memcpy(g_RegExtTmp, g_RegExt, sizeof(g_RegExt));
|
|
|
|
// Copy the registry to a temporary space
|
|
memcpy(g_RegExtTmp, g_RegExt, sizeof(g_RegExt));
|
|
|
|
// Encrypt the read
|
|
wiimote_encrypt(&g_ExtKey, &g_RegExtTmp[address & 0xffff], (address & 0xffff), (u8)size);
|
|
|
|
// Debugging
|
|
wprintf("\nEncrypted data:\n");
|
|
for (int i = 0; i < (u8)size; i++)
|
|
{
|
|
wprintf("%02x ", g_RegExtTmp[i + offset]);
|
|
if((i + 1) % 20 == 0) wprintf("\n");
|
|
}
|
|
|
|
//wprintf("\ng_RegExtTmp after: \n");
|
|
//ReadExtTmp();
|
|
//wprintf("\nFrom g_RegExt: \n");
|
|
//ReadExt();
|
|
|
|
// Update the block that SendReadDataReply will eventually send to the Wii
|
|
block = g_RegExtTmp;
|
|
}
|
|
|
|
wprintf("\n\n\n");
|
|
}
|
|
//---------
|
|
|
|
|
|
address &= 0xFFFF;
|
|
if(address + size > blockSize) {
|
|
PanicAlert("WmReadData: address + size out of bounds!");
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
SendReadDataReply(_channelID, block+address, address, (u8)size);
|
|
}
|
|
else
|
|
{
|
|
PanicAlert("WmReadData: unimplemented parameters (size: %i, addr: 0x%x!", size, rd->space);
|
|
}
|
|
LOGV(WII_IPC_WIIMOTE, 0, "===========================================================");
|
|
}
|
|
|
|
|
|
|
|
// ===================================================
|
|
/* Write data to Wiimote and Extensions registers. */
|
|
// ----------------
|
|
void WmWriteData(u16 _channelID, wm_write_data* wd)
|
|
{
|
|
LOGV(WII_IPC_WIIMOTE, 0, "========================================================");
|
|
u32 address = convert24bit(wd->address);
|
|
LOG(WII_IPC_WIIMOTE, " Write data");
|
|
LOG(WII_IPC_WIIMOTE, " Address space: %x", wd->space);
|
|
LOG(WII_IPC_WIIMOTE, " Address: 0x%06x", address);
|
|
LOG(WII_IPC_WIIMOTE, " Size: 0x%02x", wd->size);
|
|
LOG(WII_IPC_WIIMOTE, " Rumble: %x", wd->rumble);
|
|
|
|
// Write to EEPROM
|
|
if(wd->size <= 16 && wd->space == WM_SPACE_EEPROM)
|
|
{
|
|
if(address + wd->size > WIIMOTE_EEPROM_SIZE) {
|
|
PanicAlert("WmWriteData: address + size out of bounds!");
|
|
return;
|
|
}
|
|
memcpy(g_Eeprom + address, wd->data, wd->size);
|
|
|
|
// WmSendAck(_channelID, WM_WRITE_DATA);
|
|
}
|
|
// Write to registers
|
|
else if(wd->size <= 16 && (wd->space == WM_SPACE_REGS1 || wd->space == WM_SPACE_REGS2))
|
|
{
|
|
u8* block;
|
|
u32 blockSize;
|
|
switch((address >> 16) & 0xFE)
|
|
{
|
|
case 0xA2:
|
|
block = g_RegSpeaker;
|
|
blockSize = WIIMOTE_REG_SPEAKER_SIZE;
|
|
break;
|
|
case 0xA4:
|
|
block = g_RegExt; // Extension Controller register
|
|
blockSize = WIIMOTE_REG_EXT_SIZE;
|
|
LOGV(WII_IPC_WIIMOTE, 0, " *******************************************************");
|
|
LOGV(WII_IPC_WIIMOTE, 0, "");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xA4: Write ExtReg");
|
|
LOGV(WII_IPC_WIIMOTE, 0, "");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " *******************************************************");
|
|
wprintf("\n\nWmWriteData Size: %i Address: %08x Offset: %08x \n",
|
|
wd->size, address, (address & 0xffff));
|
|
break;
|
|
case 0xB0:
|
|
block = g_RegIr;
|
|
blockSize = WIIMOTE_REG_IR_SIZE;
|
|
break;
|
|
default:
|
|
PanicAlert("WmWriteData: bad register block!");
|
|
return;
|
|
}
|
|
|
|
|
|
// Remove for example 0xa40000 from the address
|
|
address &= 0xFFFF;
|
|
|
|
// Check if the address is within bounds
|
|
if(address + wd->size > blockSize) {
|
|
PanicAlert("WmWriteData: address + size out of bounds!");
|
|
return;
|
|
}
|
|
|
|
// Finally write the registers to the right structure
|
|
memcpy(block + address, wd->data, wd->size);
|
|
|
|
// -----------------------------------------
|
|
// Generate key for the Wiimote Extension
|
|
// -------------
|
|
if(blockSize == WIIMOTE_REG_EXT_SIZE)
|
|
{
|
|
// Debugging
|
|
// Write the data
|
|
wprintf("Data: ");
|
|
for (int i = 0; i < wd->size; i++)
|
|
{
|
|
wprintf("%02x ", wd->data[i]);
|
|
if((i + 1) % 25 == 0) wprintf("\n");
|
|
}
|
|
wprintf("\n");
|
|
|
|
//wprintf("Current address: %08x\n", address);
|
|
|
|
//wprintf("g_RegExt:\n");
|
|
//ReadExt();
|
|
|
|
|
|
/* Run the key generation on all writes in the key area, it doesn't matter
|
|
that we send it parts of a key, only the last full key will have an
|
|
effect */
|
|
//if(address >= 0xa40040 && address <= 0xa4004c)
|
|
if(address >= 0x40 && address <= 0x4c)
|
|
//if(address == 0x4c)
|
|
wiimote_gen_key(&g_ExtKey, &g_RegExt[0x40]);
|
|
}
|
|
// -------------
|
|
|
|
|
|
} else {
|
|
PanicAlert("WmWriteData: unimplemented parameters!");
|
|
}
|
|
|
|
// just added for home brew.... hmmmm
|
|
WmSendAck(_channelID, WM_WRITE_DATA);
|
|
LOGV(WII_IPC_WIIMOTE, 0, "==========================================================");
|
|
}
|
|
|
|
|
|
// ===================================================
|
|
/* Generate the right address for wm reports. */
|
|
// ----------------
|
|
int WriteWmReport(u8* dst, u8 channel) {
|
|
u32 Offset = 0;
|
|
hid_packet* pHidHeader = (hid_packet*)(dst + Offset);
|
|
Offset += sizeof(hid_packet);
|
|
pHidHeader->type = HID_TYPE_DATA;
|
|
pHidHeader->param = HID_PARAM_INPUT;
|
|
|
|
wm_report* pReport = (wm_report*)(dst + Offset);
|
|
Offset += sizeof(wm_report);
|
|
pReport->channel = channel;
|
|
return Offset;
|
|
}
|
|
|
|
|
|
// Custom call version
|
|
void WmRequestStatus_(u16 _channelID, int a)
|
|
{
|
|
//PanicAlert("WmRequestStatus");
|
|
LOGV(WII_IPC_WIIMOTE, 0, "================================================");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Request Status");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Channel: %04x", _channelID);
|
|
|
|
//SendStatusReport();
|
|
u8 DataFrame[1024];
|
|
u32 Offset = WriteWmReport(DataFrame, WM_STATUS_REPORT);
|
|
|
|
wm_status_report* pStatus = (wm_status_report*)(DataFrame + Offset);
|
|
Offset += sizeof(wm_status_report);
|
|
memset(pStatus, 0, sizeof(wm_status_report)); // fill the status report with zeroes
|
|
|
|
// Status values
|
|
pStatus->leds = g_Leds;
|
|
pStatus->ir = 1;
|
|
pStatus->battery = 0x4F; //arbitrary number
|
|
|
|
|
|
if(a == 1)
|
|
{
|
|
wprintf("pStatus->extension = 1\n");
|
|
pStatus->extension = 1;
|
|
}
|
|
else
|
|
{
|
|
wprintf("pStatus->extension = 0\n");
|
|
pStatus->extension = 0;
|
|
}
|
|
|
|
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Extension: %x", pStatus->extension);
|
|
LOGV(WII_IPC_WIIMOTE, 0, " SendStatusReport()");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Flags: 0x%02x", pStatus->padding1[2]);
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Battery: %d", pStatus->battery);
|
|
|
|
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
|
|
LOGV(WII_IPC_WIIMOTE, 0, "=================================================");
|
|
}
|
|
|
|
|
|
// ===================================================
|
|
/* Here we produce a status report to send to the Wii. We currently ignore the status
|
|
request rs and all its eventual instructions it may include (for example turn off
|
|
rumble or something else) and just send the status report. */
|
|
// ----------------
|
|
void WmRequestStatus(u16 _channelID, wm_request_status* rs)
|
|
{
|
|
//PanicAlert("WmRequestStatus");
|
|
LOGV(WII_IPC_WIIMOTE, 0, "================================================");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Request Status");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Rumble: %x", rs->rumble);
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Channel: %04x", _channelID);
|
|
|
|
//SendStatusReport();
|
|
u8 DataFrame[1024];
|
|
u32 Offset = WriteWmReport(DataFrame, WM_STATUS_REPORT);
|
|
|
|
wm_status_report* pStatus = (wm_status_report*)(DataFrame + Offset);
|
|
Offset += sizeof(wm_status_report);
|
|
memset(pStatus, 0, sizeof(wm_status_report)); // fill the status report with zeroes
|
|
|
|
// Status values
|
|
pStatus->leds = g_Leds;
|
|
pStatus->ir = 1;
|
|
pStatus->battery = 0x4F; //arbitrary number
|
|
|
|
// Read config value for this one
|
|
if(g_Config.bExtensionConnected)
|
|
pStatus->extension = 1;
|
|
else
|
|
pStatus->extension = 0;
|
|
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Extension: %x", pStatus->extension);
|
|
LOGV(WII_IPC_WIIMOTE, 0, " SendStatusReport()");
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Flags: 0x%02x", pStatus->padding1[2]);
|
|
LOGV(WII_IPC_WIIMOTE, 0, " Battery: %d", pStatus->battery);
|
|
|
|
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
|
|
LOGV(WII_IPC_WIIMOTE, 0, "=================================================");
|
|
}
|
|
|
|
|
|
// ===================================================
|
|
/* Here we produce the actual reply that we send to the Wii. The message is divided
|
|
into 16 bytes pieces and sent piece by piece. */
|
|
// ----------------
|
|
void SendReadDataReply(u16 _channelID, void* _Base, u16 _Address, u8 _Size)
|
|
{
|
|
LOGV(WII_IPC_WIIMOTE, 0, "=========================================");
|
|
int dataOffset = 0;
|
|
while (_Size > 0)
|
|
{
|
|
u8 DataFrame[1024];
|
|
u32 Offset = WriteWmReport(DataFrame, WM_READ_DATA_REPLY);
|
|
|
|
int copySize = _Size;
|
|
if (copySize > 16)
|
|
{
|
|
copySize = 16;
|
|
}
|
|
|
|
wm_read_data_reply* pReply = (wm_read_data_reply*)(DataFrame + Offset);
|
|
Offset += sizeof(wm_read_data_reply);
|
|
pReply->buttons = 0;
|
|
pReply->error = 0;
|
|
pReply->size = (copySize - 1) & 0xF;
|
|
pReply->address = Common::swap16(_Address + dataOffset);
|
|
|
|
|
|
// Write a pice
|
|
memcpy(pReply->data + dataOffset, _Base, copySize);
|
|
|
|
if(copySize < 16) // check if we have less than 16 bytes left to send
|
|
{
|
|
memset(pReply->data + copySize, 0, 16 - copySize);
|
|
}
|
|
dataOffset += copySize;
|
|
|
|
|
|
LOG(WII_IPC_WIIMOTE, " SendReadDataReply()");
|
|
LOG(WII_IPC_WIIMOTE, " Buttons: 0x%04x", pReply->buttons);
|
|
LOG(WII_IPC_WIIMOTE, " Error: 0x%x", pReply->error);
|
|
LOG(WII_IPC_WIIMOTE, " Size: 0x%x", pReply->size);
|
|
LOG(WII_IPC_WIIMOTE, " Address: 0x%04x", pReply->address);
|
|
|
|
// Debugging
|
|
/*
|
|
wprintf("SendReadDataReply\n");
|
|
for (int i = 0; i < sizeof(DataFrame); i++)
|
|
{
|
|
wprintf("%02x ", g_RegExt[i]);
|
|
if((i + 1) % 25 == 0) wprintf("\n");
|
|
}
|
|
wprintf("\n\n");
|
|
*/
|
|
//---------
|
|
|
|
// Send a piece
|
|
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
|
|
|
|
_Size -= copySize;
|
|
}
|
|
|
|
if (_Size != 0)
|
|
{
|
|
PanicAlert("WiiMote-Plugin: SendReadDataReply() failed");
|
|
}
|
|
LOGV(WII_IPC_WIIMOTE, 0, "==========================================");
|
|
}
|
|
|
|
|
|
} // end of namespace
|