diff options
Diffstat (limited to 'SPB/SpbTestTool/exe/command.cpp')
| -rw-r--r-- | SPB/SpbTestTool/exe/command.cpp | 660 |
1 files changed, 660 insertions, 0 deletions
diff --git a/SPB/SpbTestTool/exe/command.cpp b/SPB/SpbTestTool/exe/command.cpp new file mode 100644 index 00000000..fa559266 --- /dev/null +++ b/SPB/SpbTestTool/exe/command.cpp @@ -0,0 +1,660 @@ +/*++ + +Copyright (c) Microsoft Corporation. All rights reserved. + +Module Name: + + command.cpp + +Abstract: + + This module contains the class definitions for the various + SpbTestTool commands. + +Environment: + + user-mode + +Revision History: + +--*/ + +#include "internal.h" + +long CCommand::s_Index = 1; + +VOID +PrintCommands() +{ + printf("\n"); + printf("Commands:\n"); + printf(" open open handle to SPB controller\n"); + printf(" close close handle to SPB controller\n"); + printf(" lock lock the bus for exclusive access\n"); + printf(" unlock unlock the bus\n"); + printf(" lockconn lock the shared connection for exclusive access -\n"); + printf(" this primitive is used to synchronize with op-region\n"); + printf(" accesses by firmware\n"); + printf(" unlockconn unlock the shared connection\n"); + printf(" write {} write byte array to peripheral\n"); + printf(" > write {01 02 03}\n"); + printf(" read <numBytes> read <numBytes> from peripheral\n"); + printf(" > read 5\n"); + printf(" writeread {} <numBytes> atomically write byte array to peripheral\n"); + printf(" and read <numBytes> back\n"); + printf(" > writeread {01 02 03} 5\n"); + printf(" fullduplex {} <numBytes> simultaneously write byte array to peripheral\n"); + printf(" and read <numBytes> back\n"); + printf(" > full duplex {01 02 03} 5\n"); + printf(" signal inform the SpbTestTool driver that the\n"); + printf(" interrupt has been handled\n"); + printf(" help print command list\n"); + printf("\n"); +} + +PCCommand +CCommand::_ParseCommand( + _In_ __drv_when(return != nullptr, __drv_aliasesMem) list<string> *Parameters + ) +{ + string tag; + string name; + + PCCommand command = nullptr; + + if (Parameters->front()[0] == L'@') + { + if (PopStringParameter(Parameters, &tag) == false) + { + printf("Error - could not pop tag\n"); + return nullptr; + } + } + + if (PopStringParameter(Parameters, &name) == false) + { + return nullptr; + } + + if(_stricmp(name.c_str(), "open") == 0) + { + command = new COpenCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "close") == 0) + { + command = new CCloseCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "lock") == 0) + { + command = new CLockCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "unlock") == 0) + { + command = new CUnlockCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "lockconn") == 0) + { + command = new CLockConnectionCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "unlockconn") == 0) + { + command = new CUnlockConnectionCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "read") == 0) + { + command = new CReadCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "write") == 0) + { + command = new CWriteCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "writeread") == 0) + { + command = new CWriteReadCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "fullduplex") == 0) + { + command = new CFullDuplexCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "signal") == 0) + { + command = new CSignalInterruptCommand(Parameters, tag); + } + else if(_stricmp(name.c_str(), "help") == 0) + { + PrintCommands(); + return nullptr; + } + else + { + printf("unrecognized command %s\n", name.c_str()); + PrintCommands(); + return nullptr; + } + + if (command->Parse() == false) + { + command->DetachParameter(); //avoid double deletion + delete command; + return nullptr; + } + + return command; +} + +bool +COpenCommand::Execute( + VOID + ) +{ + // + // Open peripheral target + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_OPEN, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +COpenCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Peripheral target opened\n"); + } +} + +bool +CCloseCommand::Execute( + VOID + ) +{ + // + // Close peripheral target + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_CLOSE, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +CCloseCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Peripheral target closed\n"); + } +} + +bool +CLockCommand::Execute( + VOID + ) +{ + // + // Lock controller for peripheral target + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_LOCK, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +CLockCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Controller locked\n"); + } +} + +bool +CUnlockCommand::Execute( + VOID + ) +{ + // + // Unlock controller + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_UNLOCK, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +CUnlockCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Controller unlocked\n"); + } +} + +bool +CLockConnectionCommand::Execute( + VOID + ) +{ + // + // Lock connection for peripheral target + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_LOCK_CONNECTION, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +CLockConnectionCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Peripheral target locked\n"); + } +} + +bool +CUnlockConnectionCommand::Execute( + VOID + ) +{ + // + // Unlock connection + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_UNLOCK_CONNECTION, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +CUnlockConnectionCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Peripheral target unlocked\n"); + } +} + +bool +CReadCommand::Execute( + VOID + ) +{ + ULONG bytesRead; + + if (File == nullptr) + { + return false; + } + + if ((ReadFile(File, + Buffer, + Length, + &bytesRead, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesRead); + } + + return true; +} + +void +CReadCommand::Complete( + _In_ DWORD Status, + _In_ DWORD Information + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", Status); + } + else + { + printf("%u bytes read\n", Information); + PrintBytes(Information, Buffer); + } +} + +bool +CWriteCommand::Execute( + VOID + ) +{ + ULONG bytesWritten; + + if (File == nullptr) + { + return false; + } + + if ((WriteFile(File, + Buffer, + Length, + &bytesWritten, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesWritten); + } + + return true; +} + + +void +CWriteCommand::Complete( + _In_ DWORD Status, + _In_ DWORD Information + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", Status); + } + else + { + printf("%u bytes written\n", Information); + } +} + +bool +CWriteReadCommand::Execute( + VOID + ) +{ + ULONG bytesTransferred; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl(File, + IOCTL_SPBTESTTOOL_WRITEREAD, + WriteBuffer, + WriteLength, + Buffer, + ReadLength, + &bytesTransferred, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesTransferred); + } + + return true; +} + +void +CWriteReadCommand::Complete( + _In_ DWORD Status, + _In_ DWORD Information + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("%u bytes returned\n", Information); + PrintBytes(Information, Buffer); + } +} + +bool +CFullDuplexCommand::Execute( + VOID + ) +{ + ULONG bytesTransferred; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl(File, + IOCTL_SPBTESTTOOL_FULL_DUPLEX, + WriteBuffer, + WriteLength, + Buffer, + ReadLength, + &bytesTransferred, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesTransferred); + } + + return true; +} + +void +CFullDuplexCommand::Complete( + _In_ DWORD Status, + _In_ DWORD Information + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("%u bytes returned\n", Information); + PrintBytes(Information, Buffer); + } +} + +bool +CSignalInterruptCommand::Execute( + VOID + ) +{ + // + // Signal interrupt + // + + ULONG bytesReturned; + + if (File == nullptr) + { + return false; + } + + if ((DeviceIoControl( + File, + IOCTL_SPBTESTTOOL_SIGNAL_INTERRUPT, + nullptr, + 0, + nullptr, + 0, + &bytesReturned, + &Overlapped) == TRUE) || + (GetLastError() != ERROR_IO_PENDING)) + { + FakeCompletion(GetLastError(), bytesReturned); + } + + return true; +} + +void +CSignalInterruptCommand::Complete( + _In_ DWORD Status, + _In_ DWORD /* Information */ + ) +{ + if (Status != NO_ERROR) + { + printf("Error %u\n", GetLastError()); + } + else + { + printf("Interrupt signalled\n"); + } +} |