//
// Internal Function: UartCtlSetFifoControl
//
VOID
UartCtlSetFifoControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR fifoControlRegister = 0;
UCHAR fifoControlRegisterSaved = 0;
PUCHAR pFifoControl = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(UCHAR),
(PVOID*)(& pFifoControl),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// This value is not verified. This is as specified in the documentation.
fifoControlRegister = *pFifoControl;
// Save the value of the FCR to be written, with the reset bits unset.
fifoControlRegisterSaved = fifoControlRegister &
(~(SERIAL_FCR_RCVR_RESET | SERIAL_FCR_TXMT_RESET));
// Acquires the interrupt lock and writes the FCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
WRITE_FIFO_CONTROL(pDevExt, pDevExt->Controller, fifoControlRegister);
pDevExt->FifoControl = fifoControlRegisterSaved;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlSetChars
//
VOID
UartCtlSetChars(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_CHARS pSpecialChars = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(SERIAL_CHARS),
(PVOID*)(& pSpecialChars),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
//
// Software flow control and in-band signaling
// have not been implemented in this sample. Characters
// are not checked for valid range or values.
//
pDevExt->SpecialChars.EofChar = pSpecialChars->EofChar;
pDevExt->SpecialChars.ErrorChar = pSpecialChars->ErrorChar;
pDevExt->SpecialChars.BreakChar = pSpecialChars->BreakChar;
pDevExt->SpecialChars.EventChar = pSpecialChars->EventChar;
pDevExt->SpecialChars.XonChar = pSpecialChars->XonChar;
pDevExt->SpecialChars.XoffChar = pSpecialChars->XoffChar;
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetDtrrts
//
VOID
UartCtlGetDtrrts(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PULONG pBuffer;
UCHAR regModemControl;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(ULONG),
(PVOID*)(& pBuffer),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl &= SERIAL_DTR_STATE | SERIAL_RTS_STATE;
*pBuffer = regModemControl;
WdfRequestSetInformation(Request, sizeof(ULONG));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetModemControl
//
VOID
UartCtlGetModemControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PULONG pBuffer;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(ULONG),
(PVOID*)(&pBuffer),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and reads the modem control register.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
*pBuffer = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(ULONG));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetBaudRate
//
VOID
UartCtlGetBaudRate(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_BAUD_RATE pBaudRate = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_BAUD_RATE),
(PVOID*)(& pBaudRate),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and retrieves the current baud rate.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
pBaudRate->BaudRate = pDevExt->CurrentBaud;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(SERIAL_BAUD_RATE));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetStats
//
VOID
UartCtlGetStats(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIALPERF_STATS pStats = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIALPERF_STATS),
(PVOID*)(& pStats),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
*pStats = pDevExt->PerfStats;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(SERIALPERF_STATS));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlClrRts
//
VOID
UartCtlClrRts(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR regModemControl;
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
if (((pDevExt->HandFlow.FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_RTS_HANDSHAKE) ||
((pDevExt->HandFlow.FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_TRANSMIT_TOGGLE))
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"RTS cannot be cleared when automatic RTS flow control or "
"transmit toggling is used - %!STATUS!",
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and sets the MCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl &= ~SERIAL_MCR_RTS;
WRITE_MODEM_CONTROL(pDevExt, pDevExt->Controller, regModemControl);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetHandflow
//
VOID
UartCtlGetHandflow(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_HANDFLOW pHandFlow = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_HANDFLOW),
(PVOID*)(& pHandFlow),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
*pHandFlow = pDevExt->HandFlow;
WdfRequestSetInformation(Request, sizeof(SERIAL_HANDFLOW));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlSetDtr
//
VOID
UartCtlSetDtr(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR regModemControl;
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
if ((pDevExt->HandFlow.ControlHandShake & SERIAL_DTR_MASK) ==
SERIAL_DTR_HANDSHAKE)
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"DTR cannot be set when automatic DTR flow control is used - "
"%!STATUS!",
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and sets the MCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl |= SERIAL_MCR_DTR;
WRITE_MODEM_CONTROL(pDevExt, pDevExt->Controller, regModemControl);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlImmediateChar
//
VOID
UartCtlImmediateChar(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
UNREFERENCED_PARAMETER(Device);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
//
// Interleaving an immediate character into the write path
// has not been implemented in this sample.
//
status = STATUS_NOT_IMPLEMENTED;
TraceMessage(TRACE_LEVEL_WARNING,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlClearStats
//
VOID
UartCtlClearStats(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_SUCCESS;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
RtlZeroMemory(&pDevExt->PerfStats, sizeof(SERIALPERF_STATS));
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
void CTraceMsgLog::TraceMessage(int level, CString str)
{
CString traceMsg(_T(""));
switch(level)
{
case MSGINFO:
traceMsg.Append(_T("[INFO] "));
break;
case MSGERROR:
traceMsg.Append(_T("[ERR] "));
break;
case JAVASCRIPT_ALERT:
traceMsg.Append(_T("[JAVASCRIPT ALERT] "));
break;
default:
traceMsg.Append(_T("[DEBUG] "));
break;
}
//
traceMsg.Append(str);
//
TraceMessage(traceMsg);
}
//
// Internal Function: UartCtlSetBreakOff
//
VOID
UartCtlSetBreakOff(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
UNREFERENCED_PARAMETER(Device);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
//
// Software flow control and in-band signaling
// have not been implemented in this sample.
//
status = STATUS_NOT_IMPLEMENTED;
TraceMessage(TRACE_LEVEL_WARNING,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//--------------------------------------------------------------------------------------------------------------//
DWORD CTracer::TraceWin32Error(
DWORD dwError /*= ::GetLastError()*/,
LPCTSTR const szDescription /*= _T("Internal error")*/)
{
CWin32Error E(dwError);
TraceMessage(enMtError,NULL, _T("%s : (%d) %s"), szDescription, dwError, (LPCTSTR)E);
return dwError;
}
int KinectInternalData::WriteRegister(unsigned short registeridx, unsigned short value)
{
unsigned short reply[2];
unsigned short command[2];
int res;
command[0] = registeridx;
command[1] = value;
TraceMessage("Writing value %04x to register %04x", value, registeridx);
res = SendCommand(0x03, (unsigned char*)command, 4, (unsigned char*)reply, 4);
if (res < 0) return res;
if (res != 2)
{
WarningMessage("WriteRegister: SendCommand returned %d [%04x %04x], 0000 expected!", res, reply[0], reply[1]);
}
return 0;
};
//游戏结束
bool __cdecl CTableFrameSink::OnEventGameEnd(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
{
switch (cbReason)
{
case GER_NORMAL: //常规结束
{
//定义变量
CMD_S_GameEnd GameEnd;
ZeroMemory(&GameEnd,sizeof(GameEnd));
GameEnd.cbTotalEnd = 1;
//扑克数据
BYTE cbEndCardData[GAME_PLAYER][MAX_CENTERCOUNT];
ZeroMemory(cbEndCardData,sizeof(cbEndCardData));
try{
//获取扑克
for (WORD i=0;i<m_wPlayerCount;i++)
{
//用户过滤
if (m_cbPlayStatus[i]==FALSE) continue;
//最大牌型
BYTE cbEndCardKind = m_GameLogic.FiveFromSeven(m_cbHandCardData[i],MAX_COUNT,m_cbCenterCardData,MAX_CENTERCOUNT,cbEndCardData[i],MAX_CENTERCOUNT);
ASSERT(cbEndCardKind!=FALSE);
CopyMemory(GameEnd.cbLastCenterCardData[i],cbEndCardData[i],sizeof(BYTE)*CountArray(cbEndCardData));
}
}catch(...)
{
TraceMessage("用户过滤v最大牌型");
ASSERT(FALSE);
}
//总下注备份
LONG lTotalScore[GAME_PLAYER];
ZeroMemory(lTotalScore,sizeof(lTotalScore));
CopyMemory(lTotalScore,m_lTotalScore,sizeof(m_lTotalScore));
//胜利列表
UserWinList WinnerList[GAME_PLAYER];
ZeroMemory(WinnerList,sizeof(WinnerList));
//临时数据
BYTE bTempData[GAME_PLAYER][MAX_CENTERCOUNT];
CopyMemory(bTempData,cbEndCardData,GAME_PLAYER*MAX_CENTERCOUNT);
WORD wWinCount=0;
try{
//用户得分顺序
for (WORD i=0;i<m_wPlayerCount;i++)
{
//查找最大用户
if(!m_GameLogic.SelectMaxUser(bTempData,WinnerList[i],lTotalScore))
{
wWinCount=i;
break;
}
//删除胜利数据
for (WORD j=0;j<WinnerList[i].bSameCount;j++)
{
WORD wRemoveId=WinnerList[i].wWinerList[j];
ASSERT(bTempData[wRemoveId][0]!=0);
ZeroMemory(bTempData[wRemoveId],sizeof(BYTE)*MAX_CENTERCOUNT);
}
}
}catch(...)
{
TraceMessage("用户得分顺序");
ASSERT(FALSE);
}
//强退用户
for (WORD i=0;i<m_wPlayerCount;i++)
{
if(m_cbPlayStatus[i]==FALSE && lTotalScore[i]>0l)
{
WinnerList[wWinCount].wWinerList[WinnerList[wWinCount].bSameCount++] = i;
}
}
//得分变量
LONG lUserScore[GAME_PLAYER];
ZeroMemory(lUserScore,sizeof(lUserScore));
//CopyMemory(lTotalScore,m_lTotalScore,sizeof(m_lTotalScore));
try
{
//得分情况
for (int i=0;i<m_wPlayerCount-1;i++)
{
//胜利人数
int iWinCount = (int)WinnerList[i].bSameCount;
if(0 == iWinCount)break;
//胜利用户得分情况
for(int j=0;j<iWinCount;j++)
{
if(0 == lTotalScore[WinnerList[i].wWinerList[j]])continue;
if(j>0 && lTotalScore[WinnerList[i].wWinerList[j]] -
lTotalScore[WinnerList[i].wWinerList[j-1]] == 0)continue;
//失败用户失分情况
for(int k=i+1;k<m_wPlayerCount;k++)
{
//失败人数
if(0 == WinnerList[k].bSameCount)break;
for(int l=0;l<WinnerList[k].bSameCount;l++)
{
//用户已赔空
if(0 == lTotalScore[WinnerList[k].wWinerList[l]])continue;
WORD wLostId=WinnerList[k].wWinerList[l];
WORD wWinId=WinnerList[i].wWinerList[j];
LONG lMinScore = 0;
//上家得分数目
LONG lLastScore = ((j>0)?lTotalScore[WinnerList[i].wWinerList[j-1]]:0);
if(j>0)ASSERT(lLastScore>0L);
lMinScore = min(lTotalScore[wWinId]-lLastScore,lTotalScore[wLostId]);
for(int m=j;m<iWinCount;m++)
{
//得分数目
lUserScore[WinnerList[i].wWinerList[m]]+=lMinScore/(iWinCount-j);
}
//赔偿数目
lUserScore[wLostId]-=lMinScore;
lTotalScore[wLostId]-=lMinScore;
}
}
}
}
}catch(...)
{
TraceMessage("得分数目/赔偿数目");
ASSERT(FALSE);
}
//扣税变量
WORD wRevenue=m_pGameServiceOption->wRevenue;
//统计用户分数(税收)
for(WORD i=0;i<m_wPlayerCount;i++)
{
GameEnd.lGameScore[i]=lUserScore[i];
ASSERT(lUserScore[i]+m_lTotalScore[i]>=0L);
if(GameEnd.lGameScore[i]>0L)
{
GameEnd.lGameTax[i]=GameEnd.lGameScore[i]*wRevenue/100L;
GameEnd.lGameScore[i]-=GameEnd.lGameTax[i];
}
}
////统计用户分数
//for(WORD i=0;i<m_wPlayerCount;i++)
//{
// GameEnd.lGameScore[i]=lUserScore[i];
// GameEnd.lGameScore[i]-=GameEnd.lGameTax[i];
//}
CopyMemory(GameEnd.cbCardData,m_cbHandCardData,sizeof(m_cbHandCardData));
//发送信息
m_pITableFrame->SendTableData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
m_pITableFrame->SendLookonData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
//积分变量
for (WORD i=0;i<GAME_PLAYER;i++)
{
if (m_cbPlayStatus[i]==TRUE)
{
enScoreKind nScoreKind;
if(GameEnd.lGameScore[i]==0L)nScoreKind=enScoreKind_Draw;
else nScoreKind=(GameEnd.lGameScore[i]>0L)?enScoreKind_Win:enScoreKind_Lost;
//写入积分
m_pITableFrame->WriteUserScore(i,GameEnd.lGameScore[i],GameEnd.lGameTax[i],nScoreKind);
}
}
//结束游戏
m_pITableFrame->ConcludeGame();
return true;
}
case GER_NO_PLAYER: //没有玩家
{
//定义变量
CMD_S_GameEnd GameEnd;
ZeroMemory(&GameEnd,sizeof(GameEnd));
GameEnd.cbTotalEnd = 0;
//效验结果
WORD wUserCount=0;
for (WORD i=0;i<GAME_PLAYER;i++)
{
if(m_cbPlayStatus[i]!=FALSE)wUserCount++;
}
if(wUserCount!=1)
{
ASSERT(FALSE);
TraceMessage("没有玩家//效验结果出错");
}
//统计分数
LONG lScore = 0,lRevenue = 0;
enScoreKind nScoreKind ;
WORD wWinner = INVALID_CHAIR;
for (WORD i = 0;i<GAME_PLAYER;i++)
{
if(m_cbPlayStatus[i]==FALSE)
{
if(m_lTotalScore[i] > 0L)GameEnd.lGameScore[i]-=m_lTotalScore[i];
continue;
}
wWinner = i;
////处理税收
//for (WORD t=0;t<m_wPlayerCount;t++)
//{
// //赢家不用收税
// if(wWinner==t)continue;
// if(m_lTotalScore[t]>0L)
// {
// GameEnd.lGameScore[t]=-m_lTotalScore[t];
// m_lTotalScore[t]-=m_bUserTax[t];
// GameEnd.lGameTax[t] = m_bUserTax[t];
// }
//}
//总下注数目
LONG lAllScore = 0L;
for (WORD j = 0;j<GAME_PLAYER;j++)
{
if(wWinner==j)continue;
lAllScore += m_lTotalScore[j];
}
ASSERT(lAllScore>=0);
GameEnd.lGameScore[i] = lAllScore;
//统计税收
if(GameEnd.lGameScore[i]>0L)
{
//扣税变量
WORD wRevenue=m_pGameServiceOption->wRevenue;
GameEnd.lGameTax[i]=GameEnd.lGameScore[i]*wRevenue/100L;
GameEnd.lGameScore[i]-=GameEnd.lGameTax[i];
}
//构造扑克
CopyMemory(GameEnd.cbCardData,m_cbHandCardData,sizeof(m_cbHandCardData));
lScore=GameEnd.lGameScore[i];
lRevenue= GameEnd.lGameTax[i];
nScoreKind=(GameEnd.lGameScore[i]>0L)?enScoreKind_Win:enScoreKind_Lost;
}
//发送消息
m_pITableFrame->SendTableData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
m_pITableFrame->SendLookonData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
//写入积分
if(wWinner<GAME_PLAYER)
{
m_pITableFrame->WriteUserScore(wWinner,lScore,lRevenue,nScoreKind);
}
else TraceMessage("//写入积分ffff");
//结束游戏
m_pITableFrame->ConcludeGame();
return true;
}
case GER_USER_LEFT:
{
//效验参数
ASSERT(pIServerUserItem!=NULL);
ASSERT(wChairID<m_wPlayerCount);
//强退处理
OnUserGiveUp(wChairID);
return true;
}
}
return false;
}
//
// Internal Function: UartCtlSetHandflow
//
VOID
UartCtlSetHandflow(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_HANDFLOW pHandFlow = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(SERIAL_HANDFLOW),
(PVOID*)(& pHandFlow),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
//
// Make sure there are no invalid bits set in
// the control and handshake
//
if ((pHandFlow->ControlHandShake & SERIAL_CONTROL_INVALID) ||
(pHandFlow->FlowReplace & SERIAL_FLOW_INVALID))
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Invalid bit in SERIAL_HANDFLOW %p - "
"%!STATUS!",
pHandFlow,
status);
}
}
if (NT_SUCCESS(status))
{
//
// Software flow control and in-band signaling
// have not been implemented in this sample.
//
if ((pHandFlow->ControlHandShake & SERIAL_DSR_SENSITIVITY) ||
(pHandFlow->ControlHandShake & SERIAL_ERROR_ABORT) ||
(pHandFlow->ControlHandShake & SERIAL_DCD_HANDSHAKE) ||
(pHandFlow->FlowReplace & SERIAL_AUTO_TRANSMIT) ||
(pHandFlow->FlowReplace & SERIAL_AUTO_RECEIVE) ||
(pHandFlow->FlowReplace & SERIAL_ERROR_CHAR) ||
(pHandFlow->FlowReplace & SERIAL_NULL_STRIPPING) ||
(pHandFlow->FlowReplace & SERIAL_BREAK_CHAR) ||
(pHandFlow->FlowReplace & SERIAL_XOFF_CONTINUE) ||
((pHandFlow->FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_TRANSMIT_TOGGLE))
{
status = STATUS_NOT_IMPLEMENTED;
TraceMessage(
TRACE_LEVEL_WARNING,
TRACE_FLAG_CONTROL,
"Specified SERIAL_HANDFLOW %p has not been implemented - "
"%!STATUS!",
pHandFlow,
status);
}
}
if (NT_SUCCESS(status))
{
//
// Make sure the DTR mode is valid
//
if ((pHandFlow->ControlHandShake & SERIAL_DTR_MASK) ==
SERIAL_DTR_MASK)
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Cannot set handflow with invalid DTR mode %lu - "
"%!STATUS!",
pHandFlow->ControlHandShake,
status);
}
}
if (NT_SUCCESS(status))
{
WdfSpinLockAcquire(pDevExt->ReceiveBufferSpinLock);
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
BOOLEAN newFlowControl;
BOOLEAN prevFlowControl = UsingRXFlowControl(pDevExt);
pDevExt->HandFlow = *pHandFlow;
newFlowControl = UsingRXFlowControl(pDevExt);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
// Empty software FIFO before changing flow control
if (newFlowControl != prevFlowControl)
{
if (!newFlowControl)
{
if (pDevExt->FIFOBufferBytes > 0)
{
// If switching from flow control to no flow control,
// read bytes from the software FIFO to ring buffer before
// asserting flow control lines.
// Shouldn't have a cached buffer and bytes in the software FIFO
NT_ASSERT(!HasCachedReceiveBuffer(pDevExt));
// Using a new status variable so the IOCTL doesn't fail if
// the driver can't read the software FIFO to SerCx ring buffer, which
// may happen after the file has closed.
NTSTATUS fifoStatus = SerCxRetrieveReceiveBuffer(Device, SERIAL_SOFTWARE_FIFO_SIZE, &pDevExt->PIOReceiveBuffer);
// Read bytes from software FIFO and return the buffer
if (NT_SUCCESS(fifoStatus))
{
// Read the software FIFO bytes into the ring buffer.
// This function won't return the buffer.
UartReceiveBytesFromSoftwareFIFO(pDevExt);
// The software FIFO has been read out and should be empty now.
NT_ASSERT(pDevExt->FIFOBufferBytes == 0);
fifoStatus = SerCxProgressReceive(
Device,
pDevExt->ReceiveProgress,
SerCxStatusSuccess);
if (!NT_SUCCESS(fifoStatus))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"%!FUNC! Failed to return buffer - %!STATUS!",
fifoStatus);
NT_ASSERTMSG("SerCxProgressReceive shouldn't fail", NT_SUCCESS(fifoStatus));
}
pDevExt->PerfStats.ReceivedCount += pDevExt->ReceiveProgress;
pDevExt->ReceiveProgress = 0;
pDevExt->PIOReceiveBuffer.Buffer = NULL;
}
else
{
TraceMessage(
TRACE_LEVEL_WARNING,
TRACE_FLAG_CONTROL,
"SerCxRetrieveReceiveBuffer failed - %!STATUS!",
fifoStatus);
}
}
}
else
{
// If switching from no flow control to flow control,
// the software FIFO should already be empty.
NT_ASSERT(pDevExt->FIFOBufferBytes == 0);
}
}
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
// If software FIFO empty, re-assert flow control
// Automatic flow control MUST be re-enabled here if it's being used.
if (pDevExt->FIFOBufferBytes == 0)
{
UartFlowReceiveAvailable(Device);
}
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfSpinLockRelease(pDevExt->ReceiveBufferSpinLock);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetCommstatus
//
VOID
UartCtlGetCommstatus(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_STATUS pStat = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_STATUS),
(PVOID*)(& pStat),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
WdfSpinLockAcquire(pDevExt->DpcSpinLock);
pStat->Errors = pDevExt->ErrorWord;
pDevExt->ErrorWord = 0;
WdfSpinLockRelease(pDevExt->DpcSpinLock);
//
// Software flow control and in-band signaling
// have not been implemented in this samples. Parameters
// such as HoldReasons, AmountInIn/OutQueue, and
// WaitForImmediate have not been populated.
//
WdfRequestSetInformation(Request, sizeof(SERIAL_STATUS));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetProperties
//
VOID
UartCtlGetProperties(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PSERIAL_COMMPROP pProps = NULL;
ULONG bufferSize;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_COMMPROP),
(PVOID*)(& pProps),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
RtlZeroMemory(pProps, sizeof(SERIAL_COMMPROP));
pProps->PacketLength = sizeof(SERIAL_COMMPROP);
pProps->PacketVersion = 2;
pProps->ServiceMask = SERIAL_SP_SERIALCOMM;
pProps->MaxTxQueue = 0;
pProps->MaxRxQueue = MAXLONG;
pProps->MaxBaud = UartMaxBaudRate;
pProps->SettableBaud = SERIAL_BAUD_USER;
pProps->ProvSubType = SERIAL_SP_UNSPECIFIED;
pProps->ProvCapabilities =
SERIAL_PCF_DTRDSR |
SERIAL_PCF_RTSCTS |
SERIAL_PCF_CD |
SERIAL_PCF_TOTALTIMEOUTS |
SERIAL_PCF_INTTIMEOUTS;
pProps->SettableParams =
SERIAL_SP_PARITY |
SERIAL_SP_BAUD |
SERIAL_SP_DATABITS |
SERIAL_SP_STOPBITS |
SERIAL_SP_HANDSHAKING |
SERIAL_SP_PARITY_CHECK |
SERIAL_SP_CARRIER_DETECT;
pProps->SettableData =
SERIAL_DATABITS_5 |
SERIAL_DATABITS_6 |
SERIAL_DATABITS_7 |
SERIAL_DATABITS_8;
pProps->SettableStopParity =
SERIAL_STOPBITS_10 |
SERIAL_STOPBITS_15 |
SERIAL_STOPBITS_20 |
SERIAL_PARITY_NONE |
SERIAL_PARITY_ODD |
SERIAL_PARITY_EVEN |
SERIAL_PARITY_MARK |
SERIAL_PARITY_SPACE;
SerCxGetRingBufferUtilization(Device, NULL, &bufferSize);
pProps->CurrentTxQueue = 0;
pProps->CurrentRxQueue = bufferSize;
WdfRequestSetInformation(Request, sizeof(SERIAL_COMMPROP));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
int KinectInternalData::SendCommand(unsigned short command, unsigned char *commandbuffer, unsigned int commandbufferlength, unsigned char *replybuffer, unsigned int replybufferlength)
{
int i, j, ret = 0;
uint8_t obuf[0x2000];
uint8_t ibuf[0x2000];
ZeroMemory(obuf, 0x2000);
ZeroMemory(ibuf, 0x2000);
cam_hdr *chdr = (cam_hdr *)obuf;
cam_hdr *rhdr = (cam_hdr *)ibuf;
chdr->cmd = command;
chdr->tag = mCommandTag;
chdr->len = commandbufferlength / 2;
chdr->magic[0] = 0x47;
chdr->magic[1] = 0x4d;
memcpy (obuf + sizeof (*chdr), commandbuffer, commandbufferlength);
ret = usb_control_msg(mDeviceHandle, 0x40, 0, 0, 0, (char*)obuf, commandbufferlength + sizeof (cam_hdr), 1600);
//ret = usb_control_msg(mDeviceHandle, 0x40, 0, 0, 0, (char*)ibuf, 0x200, 1600);
if (ret < 0)
{
ErrorMessage("SendCommand: Failed to send control message! (%d)\n", ret);
return ret;
}
do
{
ret = usb_control_msg(mDeviceHandle, 0xc0, 0, 0, 0, (char*)ibuf, 0x200, 1600);
Sleep(10);
}
while (ret == 0);
TraceMessage("Control reply: %d\n", ret);
if (ret < sizeof (cam_hdr))
{
ErrorMessage ("SendCommand: Input control transfer failed (%d)\n", ret);
return ret;
}
ret -= sizeof (cam_hdr);
if (rhdr->magic[0] != 0x52 || rhdr->magic[1] != 0x42)
{
ErrorMessage ("SendCommand: Bad magic %02x %02x\n", rhdr->magic[0], rhdr->magic[1]);
return -1;
}
if (rhdr->cmd != chdr->cmd)
{
ErrorMessage ("SendCommand: Bad cmd %02x != %02x\n", rhdr->cmd, chdr->cmd);
return -1;
}
if (rhdr->tag != chdr->tag)
{
ErrorMessage ("SendCommand: Bad tag %04x != %04x\n", rhdr->tag, chdr->tag);
return -1;
}
if (rhdr->len != (ret / 2))
{
ErrorMessage ("SendCommand: Bad len %04x != %04x\n", rhdr->len, (int) (ret / 2));
return -1;
}
if (ret > replybufferlength)
{
WarningMessage ("SendCommand: Data buffer is %d bytes long, but got %d bytes\n", replybufferlength, ret);
memcpy (replybuffer, ibuf + sizeof (*rhdr), replybufferlength);
}
else
{
memcpy (replybuffer, ibuf + sizeof (*rhdr), ret);
}
mCommandTag++;
return ret;
};
//
// Internal Function: UartCtlSetBaudRate
//
VOID
UartCtlSetBaudRate(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_BAUD_RATE pBaudRate = NULL;
USHORT DivisorLatchRegs = 0;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(SERIAL_BAUD_RATE),
(PVOID*)(& pBaudRate),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
status = UartRegConvertAndValidateBaud(
pBaudRate->BaudRate,
&DivisorLatchRegs);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to convert and validate baudrate %lu - "
"%!STATUS!",
pBaudRate->BaudRate,
status);
}
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and writes the Divisor Latch.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
pDevExt->CurrentBaud = pBaudRate->BaudRate;
WRITE_DIVISOR_LATCH(pDevExt, pDevExt->Controller, DivisorLatchRegs);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetLineControl
//
VOID
UartCtlGetLineControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR lineControlRegister = 0;
PSERIAL_LINE_CONTROL pLineControl = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_LINE_CONTROL),
(PVOID*)(& pLineControl),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and reads the LCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
lineControlRegister = READ_LINE_CONTROL(pDevExt, pDevExt->Controller);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
status = UartRegLCRToStruct(lineControlRegister, pLineControl);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to calculate SERIAL_LINE_CONTROL from LCR %c - "
"%!STATUS!",
lineControlRegister,
status);
}
}
if (NT_SUCCESS(status))
{
WdfRequestSetInformation(Request, sizeof(SERIAL_LINE_CONTROL));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlSetLineControl
//
VOID
UartCtlSetLineControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR lineControlRegister = 0;
PSERIAL_LINE_CONTROL pLineControl = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(SERIAL_LINE_CONTROL),
(PVOID*)(& pLineControl),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
status = UartRegStructToLCR(pLineControl, &lineControlRegister);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to calculate LCR from SERIAL_LINE_CONTROL %p - "
"%!STATUS!",
pLineControl,
status);
}
}
if (NT_SUCCESS(status))
{
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
// Set line control, save break setting
lineControlRegister = lineControlRegister |
(READ_LINE_CONTROL(pDevExt, pDevExt->Controller) & SERIAL_LCR_BREAK);
WRITE_LINE_CONTROL(pDevExt, pDevExt->Controller, lineControlRegister);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
NTSTATUS
UartRegConvertAndValidateBaud (
_In_ ULONG SpeedBPS,
_Out_ USHORT * DivisorLatch
)
{
NTSTATUS status = STATUS_SUCCESS;
USHORT divisor = 0;
ULONG realBaud = 0;
status = UartRegBaudToDivisorLatch(SpeedBPS, &divisor);
if (NT_SUCCESS(status))
{
//
// Determine if difference between desired and real
// baud rate is within acceptable tolerance.
//
status = UartRegDivisorLatchToBaud(
divisor,
&realBaud);
if (NT_SUCCESS(status))
{
ULONG baudDifference;
if (SpeedBPS > realBaud)
{
baudDifference = SpeedBPS - realBaud;
}
else
{
baudDifference = realBaud - SpeedBPS;
}
KFLOATING_SAVE kFloatSave;
status = KeSaveFloatingPointState(&kFloatSave);
if (NT_SUCCESS(status))
{
if((DOUBLE)(baudDifference) / (DOUBLE)SpeedBPS >
UartBaudRateErrorTolerance)
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Desired baudrate %lu exceeds error tolerance "
"(%.2f%%) - %!STATUS!",
SpeedBPS,
(UartBaudRateErrorTolerance*100),
status);
}
KeRestoreFloatingPointState(&kFloatSave);
}
else
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failure saving floating point state - %!STATUS!",
status);
}
}
}
if (NT_SUCCESS(status))
{
*DivisorLatch = divisor;
}
return status;
}
