/* Application du préconditionneur */
void Pastix_Precond(void *arg, PASTIX_FLOAT *s, PASTIX_FLOAT *d, int flag)
{
sopthread_data_t *argument = (sopthread_data_t *)arg;
Sopalin_Data_t *sopalin_data = (Sopalin_Data_t *)(argument->data);
SolverMatrix *datacode = sopalin_data->datacode;
SopalinParam *sopar = sopalin_data->sopar;
MPI_Comm pastix_comm = PASTIX_COMM;
PASTIX_INT me = argument->me;
MULTITHREAD_BEGIN;
CscCopy(sopalin_data, me, s, UPDOWN_SM2XTAB,
UPDOWN_SM2XSZE, UPDOWN_SM2XNBR, pastix_comm);
MULTITHREAD_END(1);
/* M-1 updo -> updo */
#ifdef PRECOND
if (sopar->iparm[IPARM_ONLY_RAFF] == API_NO)
{
SYNCHRO_THREAD;
API_CALL(up_down_smp)(arg);
SYNCHRO_THREAD;
}
#endif
MULTITHREAD_BEGIN;
CscCopy(sopalin_data, me, UPDOWN_SM2XTAB, d,
UPDOWN_SM2XSZE, UPDOWN_SM2XNBR, pastix_comm);
MULTITHREAD_END(0);
if (flag)
SYNCHRO_THREAD;
}
static inline
void API_CALL(wait_contrib_comp_2d)(Sopalin_Data_t *sopalin_data,
PASTIX_INT me, PASTIX_INT i){
SolverMatrix *datacode = sopalin_data->datacode;
#ifdef TRACE_SOPALIN
Thread_Data_t *thread_data = sopalin_data->thread_data[me];
#endif
#ifdef SMP_SOPALIN
PASTIX_INT firsttask = TASK_MASTER(i);
#endif
/* Attente contribution locale et MPI */
#if (defined FORCE_CONSO)
if (THREAD_FUNNELED_OFF)
{
while ((!(TASK_BTAGPTR(i)))
|| (!(RTASK_COEFTAB(i))))
{
API_CALL(rcsd_testall_fab)(sopalin_data, me);
}
}
else
#endif
{
if (THREAD_COMM_OFF)
{
while ((TASK_BTAGPTR(i) == NULL) && (sopalin_data->taskmark[i] > 0))
{
ASSERTDBG(i == firsttask, MOD_SOPALIN);
RECV_ONE_BLOCK;
}
}
}
trace_begin_task(thread_data->tracefile,
SOPALIN_CLOCK_TRACE, SOLV_PROCNUM, me, 1,
STATE_WAITLOC, i);
#if (DBG_PASTIX_DYNSCHED > 0)
MUTEX_LOCK(&(sopalin_data->mutex_task[i]));
ASSERTDBG(((TASK_TASKID(i) == E2) && (sopalin_data->taskmark[i] == 0))
|| ((TASK_TASKID(i) == E1) &&
(sopalin_data->taskmark[i] == 1)), MOD_SOPALIN);
ASSERTDBG(TASK_BTAGPTR(i) != NULL, MOD_SOPALIN);
ASSERTDBG(RTASK_COEFTAB(i) != NULL, MOD_SOPALIN);
sopalin_data->taskmark[i]++;
MUTEX_UNLOCK(&(sopalin_data->mutex_task[i]));
#endif
MUTEX_LOCK(&(sopalin_data->mutex_task[firsttask]));
while ((!(TASK_BTAGPTR(i)))
|| (!(RTASK_COEFTAB(i))))
COND_WAIT(&(sopalin_data->cond_task[firsttask]),
&(sopalin_data->mutex_task[firsttask]));
MUTEX_UNLOCK(&(sopalin_data->mutex_task[firsttask]));
}
void
_gdk_window_move_resize_child (GdkWindow *window,
gint x,
gint y,
gint width,
gint height)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
GDK_NOTE (MISC, g_print ("_gdk_window_move_resize_child: %s@%+d%+d %dx%d@%+d%+d\n",
_gdk_win32_drawable_description (window),
obj->x, obj->y, width, height, x, y));
if (width > 65535 || height > 65535)
{
g_warning ("Native children wider or taller than 65535 pixels are not supported.");
if (width > 65535)
width = 65535;
if (height > 65535)
height = 65535;
}
obj->x = x;
obj->y = y;
obj->width = width;
obj->height = height;
_gdk_win32_window_tmp_unset_parent_bg (window);
_gdk_win32_window_tmp_unset_bg (window, TRUE);
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
"NOACTIVATE|NOZORDER)\n",
GDK_WINDOW_HWND (window),
obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y,
width, height));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y,
width, height,
SWP_NOACTIVATE | SWP_NOZORDER));
//_gdk_win32_window_tmp_reset_parent_bg (window);
_gdk_win32_window_tmp_reset_bg (window, TRUE);
}
static inline void API_CALL(wait_contrib_comp_1d)(Sopalin_Data_t *sopalin_data, PASTIX_INT me, PASTIX_INT i){
SolverMatrix *datacode = sopalin_data->datacode;
#ifdef TRACE_SOPALIN
Thread_Data_t *thread_data = sopalin_data->thread_data[me];
#endif
#if (defined FORCE_CONSO)
if (THREAD_FUNNELED_OFF)
{
/* Attente en Multiple / force_conso */
while(TASK_CTRBCNT(i))
{
API_CALL(rcsd_testall_fab)(sopalin_data, me);
}
}
else
#endif
{
if (THREAD_COMM_OFF)
{
/* Attente en multiple sans force conso */
while(TASK_FTGTCNT(i))
{
RECV_ONE_FANIN;
}
}
}
trace_begin_task(thread_data->tracefile,
SOPALIN_CLOCK_TRACE, SOLV_PROCNUM, me, 1,
STATE_WAITLOC, i);
MUTEX_LOCK(&(sopalin_data->mutex_task[i]));
#if (DBG_PASTIX_DYNSCHED > 0)
ASSERTDBG(sopalin_data->taskmark[i] == 0, MOD_SOPALIN);
sopalin_data->taskmark[i]++;
#endif
while (TASK_CTRBCNT(i))
{
COND_WAIT(&(sopalin_data->cond_task[i]), &(sopalin_data->mutex_task[i]));
}
MUTEX_UNLOCK(&(sopalin_data->mutex_task[i]));
}
BOOL
print_ndas_device_info(
const NDASCOMM_CONNECTION_INFO* pci)
{
BOOL success = FALSE;
HNDAS hNdas = NULL;
NDAS_DEVICE_HARDWARE_INFO di;
API_CALL_JMP(fail, hNdas = NdasCommConnect(pci));
/* NDAS device information */
ZeroMemory(&di, sizeof(NDAS_DEVICE_HARDWARE_INFO));
di.Size = sizeof(NDAS_DEVICE_HARDWARE_INFO);
API_CALL_JMP(fail, NdasCommGetDeviceHardwareInfo(hNdas, &di) );
_tprintf(_T(" Hardware type : %d\n"), di.HardwareType);
_tprintf(_T(" Hardware version : %d\n"), di.HardwareVersion);
_tprintf(_T(" Hardware protocol type : %d\n"), di.ProtocolType);
_tprintf(_T(" Hardware protocol version : %d\n"), di.ProtocolVersion);
_tprintf(_T(" Number of command processing slots : %d\n"), di.NumberOfCommandProcessingSlots);
_tprintf(_T(" Maximum transfer blocks : %d\n"), di.MaximumTransferBlocks);
_tprintf(_T(" Maximum targets : %d\n"), di.MaximumNumberOfTargets);
_tprintf(_T(" Maximum LUs : %d\n"), di.MaximumNumberOfLUs);
_tprintf(_T(" Header encryption : %s\n"), bool_string(di.HeaderEncryptionMode));
_tprintf(_T(" Header digest : %s\n"), bool_string(di.HeaderDigestMode));
_tprintf(_T(" Data encryption : %s\n"), bool_string(di.DataEncryptionMode));
_tprintf(_T(" Data Digest : %s\n"), bool_string(di.DataDigestMode));
_tprintf(_T("\n"));
success = TRUE;
fail:
if (NULL != hNdas)
{
API_CALL(NdasCommDisconnect(hNdas));
}
return success;
}
/*
Function: method)
Launch sopaparam->nbthrdcomm threads which will compute
<method_smp)>.
Parameters:
datacode - PaStiX <SolverMatrix> structure.
sopaparam - <SopalinParam> parameters structure.
*/
void raff_thread(SolverMatrix *datacode, SopalinParam *sopaparam, void*(*method)(void *))
{
Sopalin_Data_t *sopalin_data = NULL;
BackupSolve_t b;
MALLOC_INTERN(sopalin_data, 1, Sopalin_Data_t);
solve_backup(datacode,&b);
sopalin_init(sopalin_data, datacode, sopaparam, 0);
sopalin_launch_thread(sopalin_data,
SOLV_PROCNUM, SOLV_PROCNBR, datacode->btree,
sopalin_data->sopar->iparm[IPARM_VERBOSE],
SOLV_THRDNBR, method, sopalin_data,
sopaparam->nbthrdcomm, API_CALL(sopalin_updo_comm), sopalin_data,
OOC_THREAD_NBR, ooc_thread, sopalin_data);
sopalin_clean(sopalin_data, 2);
solve_restore(datacode,&b);
memFree_null(sopalin_data);
}
int
CpGetEncryptionMode(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_VCMD_PARAM param_vcmd;
/* PNDASCOMM_HANDLE_CONTEXT Context;
UINT16 HeaderEnc=FALSE;
UINT16 DataEnc = FALSE; */
//
// Get arguments.
//
if(argc < 2) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
_ftprintf(stdout, _T("Starting the operation...\n"));
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out);
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
_tprintf(L"This vendor operation is not supported yet\n");
/*
Context = NdasHandleToContext(hNDAS);
lsp_get_handle_info(
Context->hLSP,
lsp_handle_info_hw_header_encrypt_algo,
&HeaderEnc, sizeof(HeaderEnc));
lsp_get_handle_info(
Context->hLSP,
lsp_handle_info_hw_data_encrypt_algo,
&DataEnc, sizeof(DataEnc));
*/
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
// _ftprintf(stderr, _T("\nRetransmission time: %d milli-seconds.\n"), param_vcmd.GET_MAX_CONN_TIME.MaxConnTime);
return GetLastError();
}
int
CpSetEncryptionMode(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_VCMD_PARAM param_vcmd;
ULONG HeaderEnc;
ULONG DataEnc;
//
// Get arguments.
//
if(argc < 4) {
_ftprintf(stderr, _T("ERROR: Header encryption mode and data encryption mode is required.\n"));
return -1;
}
HeaderEnc = _tcstoul(argv[2], NULL, 10);
if(HeaderEnc != 0 && HeaderEnc!=1) {
_ftprintf(stderr, _T("ERROR: Avaiable header encryption mode is 0 (off) or 1 (hash encryption).\n"));
return -1;
}
DataEnc = _tcstoul(argv[2], NULL, 10);
if(DataEnc != 0 && DataEnc!=1) {
_ftprintf(stderr, _T("ERROR: Avaiable header encryption mode is 0 (off) or 1 (hash encryption).\n"));
return -1;
}
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
/* Log in as super user */
ci.PrivilegedOEMCode = NDAS_DEFAULT_PRIVILEGED_OEM_CODE;
/* Privileged Connection cannot use lock commands */
ci.Flags = NDASCOMM_CNF_DISABLE_LOCK_CLEANUP_ON_CONNECT;
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out);
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
//
// Set encryption mode
//
_ftprintf(stderr, _T("Applying setting to the device...\n"));
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
param_vcmd.SET_ENC_OPT.EncryptHeader = HeaderEnc;
param_vcmd.SET_ENC_OPT.EncryptData = DataEnc;
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_enc_opt, ¶m_vcmd, NULL, 0, NULL, 0), out);
_ftprintf(stderr, _T("Resetting the device...\n"));
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_reset, ¶m_vcmd, NULL, 0, NULL, 0), out);
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
return GetLastError();
}
int
__cdecl
_tmain(int argc, TCHAR** argv)
{
BOOL success;
UINT32 i;
UINT32 nUnitDevices;
NDASCOMM_CONNECTION_INFO ci = {0};
// getc(stdin);
// Sleep(3000);
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
if (!check_ndascomm_api_version())
{
return 1;
}
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
success = (argc > 1) && parse_connection_info(&ci, argc - 1, argv + 1);
if (!success)
{
usage();
return 1;
}
API_CALL(success = NdasCommInitialize());
if (!success)
{
_tprintf(_T("Subsystem initialization failed\n"));
print_last_error_message();
return 1;
}
ci.LoginType= NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tprintf(_T("\n"));
_tprintf(_T("NDAS device information\n\n"));
success = print_ndas_device_info(&ci);
ci.LoginType = NDASCOMM_LOGIN_TYPE_DISCOVER;
nUnitDevices = get_ndas_unit_device_count(&ci);
if (0 == nUnitDevices)
{
_tprintf(_T(" No unit devices are found.\n"));
}
else if ((UINT)-1 == nUnitDevices)
{
_tprintf(_T(" Failed to get device count\n"));
nUnitDevices = 0;
}
for (i = 0; i < nUnitDevices; i++)
{
_tprintf(_T(" Unit device [%d/%d]\n\n"), i + 1, nUnitDevices);
ci.UnitNo = i;
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL;
success = print_ndas_unitdevice_info(&ci);
ci.LoginType = NDASCOMM_LOGIN_TYPE_DISCOVER;
success = print_ndas_unitdevice_stat(&ci);
_tprintf(_T("\n"));
}
API_CALL(NdasCommUninitialize());
return GetLastError();
}
int
CpComare(int argc, _TCHAR* argv[])
{
HNDAS hNDAS1 = NULL;
HNDAS hNDAS2 = NULL;
NDASCOMM_CONNECTION_INFO ci;
BOOL bResults;
PBYTE Buffer1 = NULL, Buffer2 = NULL;
NDAS_DIB_V2 Dib;
static const SectorPerOp = 64;
NDAS_DEVICE_ID SrcAddr1, SrcAddr2;
UINT64 StartAddr;
UINT64 IoLength;
UINT32 MisMatchCount;
//
// Get arguments.
//
if(argc < 2) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
_ftprintf(stderr, _T("%s %s\n"), argv[0], argv[1]);
// Argv[0]: SrcAddr1
bResults = ConvertMacToNodeId(argv[0], &SrcAddr1);
if (!bResults) {
_ftprintf(stderr, _T("Invalid device ID.\n"));
return -1;
}
SrcAddr1.VID = 1;
bResults = ConvertMacToNodeId(argv[1], &SrcAddr2);
if (!bResults) {
_ftprintf(stderr, _T("Invalid device ID.\n"));
return -1;
}
SrcAddr2.VID = 1;
Buffer1 = (PBYTE)malloc(SectorPerOp * 512);
Buffer2 = (PBYTE)malloc(SectorPerOp * 512);
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login to source 1
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_DEVICE_ID;
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
ci.Address.DeviceId = SrcAddr1;
API_CALL_JMP( hNDAS1 = NdasCommConnect(&ci), out);
//
// Connect and login to source 2
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_DEVICE_ID;
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
ci.Address.DeviceId = SrcAddr2;
API_CALL_JMP( hNDAS2 = NdasCommConnect(&ci), out);
bResults = NdasCommBlockDeviceRead(
hNDAS1,
NDAS_BLOCK_LOCATION_DIB_V2,
1,
(PBYTE)&Dib);
if (!bResults) {
goto out;
}
if (Dib.Signature != NDAS_DIB_V2_SIGNATURE) {
_ftprintf(stdout, _T("Dib not found\n"));
goto out;
}
// Compare
_ftprintf(stdout, _T("Comparing 0x%I64x sectors\n"), Dib.sizeUserSpace);
StartAddr = 0;
IoLength = SectorPerOp;
MisMatchCount = 0;
while(TRUE) {
if (StartAddr + IoLength >= Dib.sizeUserSpace) {
// Last part.
IoLength = Dib.sizeUserSpace - StartAddr;
}
bResults = NdasCommBlockDeviceRead(
hNDAS1,
StartAddr,
IoLength,
Buffer1);
if (!bResults) {
_ftprintf(stdout, _T("Failed to read from source 1\n"));
goto out;
}
bResults = NdasCommBlockDeviceRead(
hNDAS2,
StartAddr,
IoLength,
Buffer2);
if (!bResults) {
_ftprintf(stdout, _T("Failed to read from source 2\n"));
goto out;
}
if (memcmp(Buffer1, Buffer2, (size_t)IoLength * 512) == 0) {
} else {
MisMatchCount++;
_ftprintf(stdout, _T("Mismatch at 0x%I64x:%x\n"), StartAddr, IoLength);
if (MisMatchCount > 20) {
_ftprintf(stdout, _T("Too much mismatch. Exiting\n"));
break;
}
}
if (StartAddr%(100 * 1024 * 2)==0) { // Print progress in every 100M
_ftprintf(stdout, _T("%d%%\n"), StartAddr*100/Dib.sizeUserSpace);
}
StartAddr += IoLength;
if (StartAddr >= Dib.sizeUserSpace) {
break;
}
}
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if (Buffer1)
free(Buffer1);
if (Buffer2)
free(Buffer2);
if(hNDAS1)
{
NdasCommDisconnect(hNDAS1);
hNDAS1 = NULL;
}
if(hNDAS2)
{
NdasCommDisconnect(hNDAS2);
hNDAS2 = NULL;
}
NdasCommUninitialize();
return GetLastError();
}
int
CpSetRetTime(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_VCMD_PARAM param_vcmd;
ULONG retTime;
//
// Get arguments.
//
if(argc < 3) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
retTime = _tcstoul(argv[2], NULL, 10);
if(retTime == 0) {
//
// Check to see if a user inputs the zero.
//
if( argv[2][0] != _T('0') ||
argv[2][1] != _T('\0')
) {
_ftprintf(stderr, _T("ERROR: Invalid timeout value.\n"));
return -1;
}
}
_ftprintf(stdout, _T("Starting the operation...\n"));
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
/* Log in as super user */
ci.PrivilegedOEMCode = NDAS_DEFAULT_PRIVILEGED_OEM_CODE;
/* Privileged Connection cannot use lock commands */
ci.Flags = NDASCOMM_CNF_DISABLE_LOCK_CLEANUP_ON_CONNECT;
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out);
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
//
// Set connection timeout
//
_ftprintf(stderr, _T("Applying setting to the device...\n"));
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
param_vcmd.SET_RET_TIME.RetTime = retTime;
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_ret_time, ¶m_vcmd, NULL, 0, NULL, 0), out);
_ftprintf(stderr, _T("Resetting the device...\n"));
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_reset, ¶m_vcmd, NULL, 0, NULL, 0), out);
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
return GetLastError();
}
int
CpQueryConTimeout(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_VCMD_PARAM param_vcmd;
//
// Get arguments.
//
if(argc < 2) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
_ftprintf(stdout, _T("Starting the operation...\n"));
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out);
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
//
// Query Connection timeout
//
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_get_max_conn_time, ¶m_vcmd, NULL, 0, NULL, 0), out);
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
_ftprintf(stderr, _T("\nConnection timeout: %d.\n"), param_vcmd.GET_MAX_CONN_TIME.MaxConnTime);
return GetLastError();
}
void
gdk_window_move_region (GdkWindow *window,
GdkRegion *region,
gint dx,
gint dy)
{
GdkRegion *invalidate_region;
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkRectangle src_rect, dest_rect;
HRGN hrgn;
RECT clipRect, destRect;
g_return_if_fail (GDK_IS_WINDOW (window));
if (GDK_WINDOW_DESTROYED (window))
return;
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
if (dx == 0 && dy == 0)
return;
/* Move the current invalid region */
if (obj->update_area)
gdk_region_offset (obj->update_area, dx, dy);
/* impl->position_info.clip_rect isn't meaningful for toplevels */
if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
src_rect = impl->position_info.clip_rect;
else
{
src_rect.x = 0;
src_rect.y = 0;
src_rect.width = impl->width;
src_rect.height = impl->height;
}
invalidate_region = gdk_region_rectangle (&src_rect);
dest_rect = src_rect;
dest_rect.x += dx;
dest_rect.y += dy;
gdk_rectangle_intersect (&dest_rect, &src_rect, &dest_rect);
if (dest_rect.width > 0 && dest_rect.height > 0)
{
GdkRegion *tmp_region;
tmp_region = gdk_region_rectangle (&dest_rect);
gdk_region_subtract (invalidate_region, tmp_region);
gdk_region_destroy (tmp_region);
}
/* no guffaw scroll on win32 */
hrgn = _gdk_win32_gdkregion_to_hrgn(invalidate_region, 0, 0);
gdk_region_destroy (invalidate_region);
destRect.left = dest_rect.y;
destRect.top = dest_rect.x;
destRect.right = dest_rect.x + dest_rect.width;
destRect.bottom = dest_rect.y + dest_rect.height;
clipRect.left = src_rect.y;
clipRect.top = src_rect.x;
clipRect.right = src_rect.x + src_rect.width;
clipRect.bottom = src_rect.y + src_rect.height;
g_print ("ScrollWindowEx(%d, %d, ...) - if you see this work, remove trace;)\n", dx, dy);
API_CALL(ScrollWindowEx, (GDK_WINDOW_HWND (window),
dx, dy, /* in: scroll offsets */
NULL, /* in: scroll rect, NULL == entire client area */
&clipRect, /* in: restrict to */
hrgn, /* in: update region */
NULL, /* out: update rect */
SW_INVALIDATE));
API_CALL(DeleteObject, (hrgn));
}
void
gdk_window_scroll (GdkWindow *window,
gint dx,
gint dy)
{
GdkRegion *invalidate_region;
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GList *tmp_list;
GdkWindowParentPos parent_pos;
HRGN native_invalidate_region;
g_return_if_fail (GDK_IS_WINDOW (window));
if (GDK_WINDOW_DESTROYED (window))
return;
GDK_NOTE (EVENTS, g_print ("gdk_window_scroll: %p %d,%d\n",
GDK_WINDOW_HWND (window), dx, dy));
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
if (dx == 0 && dy == 0)
return;
/* Move the current invalid region */
if (obj->update_area)
gdk_region_offset (obj->update_area, dx, dy);
gdk_window_compute_parent_pos (impl, &parent_pos);
parent_pos.x += obj->x;
parent_pos.y += obj->y;
parent_pos.win32_x += impl->position_info.x;
parent_pos.win32_y += impl->position_info.y;
parent_pos.clip_rect = impl->position_info.clip_rect;
gdk_window_tmp_unset_bg (window);
native_invalidate_region = CreateRectRgn (0, 0, 0, 0);
if (native_invalidate_region == NULL)
WIN32_API_FAILED ("CreateRectRgn");
API_CALL (ScrollWindowEx, (GDK_WINDOW_HWND (window),
dx, dy, NULL, NULL,
native_invalidate_region, NULL, SW_SCROLLCHILDREN));
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
tmp_list = obj->children;
while (tmp_list)
{
GDK_WINDOW_OBJECT(tmp_list->data)->x += dx;
GDK_WINDOW_OBJECT(tmp_list->data)->y += dy;
gdk_window_postmove (tmp_list->data, &parent_pos, FALSE);
tmp_list = tmp_list->next;
}
if (native_invalidate_region != NULL)
{
invalidate_region = _gdk_win32_hrgn_to_region (native_invalidate_region);
gdk_region_offset (invalidate_region, impl->position_info.x_offset,
impl->position_info.y_offset);
gdk_window_invalidate_region (window, invalidate_region, TRUE);
gdk_region_destroy (invalidate_region);
GDI_CALL (DeleteObject, (native_invalidate_region));
}
}
int
CpDeviceStandby(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_IDE_REGISTER IdeRegister;
//
// Get arguments.
//
if(argc < 2) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
_ftprintf(stdout, _T("Starting the operation...\n"));
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID*/
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = TRUE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out);
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
//
// Request the NDAS device to enter Standby mode
//
ZeroMemory(&IdeRegister, sizeof(NDASCOMM_IDE_REGISTER));
IdeRegister.command.command = 0xE0; /* WIN_STANDBYNOW1 */
IdeRegister.device.dev = 0;
API_CALL_JMP(NdasCommIdeCommand(hNDAS, &IdeRegister, NULL, 0, NULL, 0), out);
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
return GetLastError();
}
int
CpQueryLockOwner(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_VCMD_PARAM param_vcmd;
ULONG lockIdx;
//
// Get arguments.
//
if(argc < 3) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
lockIdx = _tcstoul(argv[2], NULL, 10);
if(lockIdx == 0) {
//
// Check to see if a user inputs the zero.
//
if( argv[2][0] != _T('0') ||
argv[2][1] != _T('\0')
) {
_ftprintf(stderr, _T("ERROR: Invalid timeout value.\n"));
return -1;
}
}
_ftprintf(stdout, _T("Starting the operation...\n"));
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-only privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out );
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
//
// Query lock owner
//
_ftprintf(stderr, _T("Querying lock #%u's owner of the device...\n"), (ULONG)(UINT8)lockIdx);
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
param_vcmd.GET_OWNER_SEMA.Index = (UINT8)lockIdx;
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_get_owner_sema, ¶m_vcmd, NULL, 0, NULL, 0), out);
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
} else {
_ftprintf(stdout, _T("Owner's addr:%02X%02X%02X%02X%02X%02X%02X%02X\n"),
param_vcmd.GET_OWNER_SEMA.AddressLPX[0],
param_vcmd.GET_OWNER_SEMA.AddressLPX[1],
param_vcmd.GET_OWNER_SEMA.AddressLPX[2],
param_vcmd.GET_OWNER_SEMA.AddressLPX[3],
param_vcmd.GET_OWNER_SEMA.AddressLPX[4],
param_vcmd.GET_OWNER_SEMA.AddressLPX[5],
param_vcmd.GET_OWNER_SEMA.AddressLPX[6],
param_vcmd.GET_OWNER_SEMA.AddressLPX[7]);
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
return GetLastError();
}
void
_gdk_window_move_resize_child (GdkWindow *window,
gint x,
gint y,
gint width,
gint height)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkWin32PositionInfo new_info;
GdkWindowParentPos parent_pos;
GList *tmp_list;
gint d_xoffset, d_yoffset;
gint dx, dy;
gboolean is_move;
gboolean is_resize;
GdkRegion *new_clip_region;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
GDK_NOTE (MISC, g_print ("_gdk_window_move_resize_child: %s@%+d%+d %dx%d@%+d%+d\n",
_gdk_win32_drawable_description (window),
obj->x, obj->y,
width, height, x, y));
dx = x - obj->x;
dy = y - obj->y;
is_move = dx != 0 || dy != 0;
is_resize = impl->width != width || impl->height != height;
if (!is_move && !is_resize)
{
GDK_NOTE (MISC, g_print ("... neither move or resize\n"));
return;
}
GDK_NOTE (MISC, g_print ("... %s%s\n",
is_move ? "is_move " : "",
is_resize ? "is_resize" : ""));
obj->x = x;
obj->y = y;
impl->width = width;
impl->height = height;
gdk_window_compute_parent_pos (impl, &parent_pos);
gdk_window_compute_position (impl, &parent_pos, &new_info);
new_clip_region =
gdk_window_clip_changed (window, &impl->position_info.clip_rect, &new_info.clip_rect);
parent_pos.x += obj->x;
parent_pos.y += obj->y;
parent_pos.win32_x += new_info.x;
parent_pos.win32_y += new_info.y;
parent_pos.clip_rect = new_info.clip_rect;
d_xoffset = new_info.x_offset - impl->position_info.x_offset;
d_yoffset = new_info.y_offset - impl->position_info.y_offset;
if (d_xoffset != 0 || d_yoffset != 0)
{
GDK_NOTE (MISC, g_print ("... d_offset=%+d%+d\n", d_xoffset, d_yoffset));
if (!ScrollWindowEx (GDK_WINDOW_HWND (window),
-d_xoffset, -d_yoffset, /* in: scroll offsets */
NULL, /* in: scroll rect, NULL == entire client area */
NULL, /* in: restrict to */
NULL, /* in: update region */
NULL, /* out: update rect */
SW_SCROLLCHILDREN))
WIN32_API_FAILED ("ScrollWindowEx");
if (dx != d_xoffset || dy != d_yoffset || is_resize)
{
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
"NOACTIVATE|NOZORDER%s%s)\n",
GDK_WINDOW_HWND (window),
new_info.x, new_info.y,
new_info.width, new_info.height,
(is_move ? "" : "|NOMOVE"),
(is_resize ? "" : "|NOSIZE")));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
new_info.x, new_info.y,
new_info.width, new_info.height,
SWP_NOACTIVATE | SWP_NOZORDER |
(is_move ? 0 : SWP_NOMOVE) |
(is_resize ? 0 : SWP_NOSIZE)));
}
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
if (!impl->position_info.mapped && new_info.mapped && GDK_WINDOW_IS_MAPPED (obj))
{
GDK_NOTE (MISC, g_print ("... ShowWindow(%p, SW_SHOWNA)\n",
GDK_WINDOW_HWND (window)));
ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNA);
}
impl->position_info = new_info;
tmp_list = obj->children;
while (tmp_list)
{
gdk_window_postmove (tmp_list->data, &parent_pos, FALSE);
tmp_list = tmp_list->next;
}
}
else
{
if (impl->position_info.mapped && !new_info.mapped)
{
GDK_NOTE (MISC, g_print ("... ShowWindow(%p, SW_HIDE)\n",
GDK_WINDOW_HWND (window)));
ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
}
GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
"NOACTIVATE|NOZORDER%s%s)\n",
GDK_WINDOW_HWND (window),
new_info.x, new_info.y,
new_info.width, new_info.height,
(is_move ? "" : "|NOMOVE"),
(is_resize ? "" : "|NOSIZE")));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
new_info.x, new_info.y,
new_info.width, new_info.height,
SWP_NOACTIVATE | SWP_NOZORDER |
(is_move ? 0 : SWP_NOMOVE) |
(is_resize ? 0 : SWP_NOSIZE)));
tmp_list = obj->children;
while (tmp_list)
{
gdk_window_postmove (tmp_list->data, &parent_pos, FALSE);
tmp_list = tmp_list->next;
}
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
if (!impl->position_info.mapped && new_info.mapped && GDK_WINDOW_IS_MAPPED (obj))
{
GDK_NOTE (MISC, g_print ("... ShowWindow(%p, SW_SHOWNA)\n",
GDK_WINDOW_HWND (window)));
ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNA);
}
impl->position_info = new_info;
}
if (new_clip_region)
gdk_window_post_scroll (window, new_clip_region);
}
int
CpSetMacAddress(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
NDASCOMM_VCMD_PARAM param_vcmd;
_TCHAR *MacAddress;
size_t argv_len;
ULONG MacAddressSegs[6];
//
// Get arguments.
//
if(argc < 3) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
// Mac address : XX:XX:XX:XX:XX:XX
MacAddress = argv[2];
if(17 != _tcslen(MacAddress) ||
_T(':') != MacAddress[2] ||
_T(':') != MacAddress[5] ||
_T(':') != MacAddress[8] ||
_T(':') != MacAddress[11] ||
_T(':') != MacAddress[14])
{
_ftprintf(stderr, _T("ERROR: Invalid MAC address. \n"));
return -1;
}
if(6 != _stscanf(MacAddress, _T("%02X:%02X:%02X:%02X:%02X:%02X"),
&MacAddressSegs[0],
&MacAddressSegs[1],
&MacAddressSegs[2],
&MacAddressSegs[3],
&MacAddressSegs[4],
&MacAddressSegs[5]))
{
_ftprintf(stderr, _T("ERROR: Invalid MAC address. \n"));
return -1;
}
_ftprintf(stdout, _T("Starting the operation...\n"));
SetLastError(0);
API_CALL(NdasCommInitialize());
//
// Connect and login
//
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_ID; /* Use NDAS ID */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
/* Log in as super user */
ci.PrivilegedOEMCode = NDAS_DEFAULT_PRIVILEGED_OEM_CODE;
/* Privileged Connection cannot use lock commands */
ci.Flags = NDASCOMM_CNF_DISABLE_LOCK_CLEANUP_ON_CONNECT;
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
_tcsncpy(ci.Address.NdasId.Id, argv[0], 20); /* ID */
_tcsncpy(ci.Address.NdasId.Key, argv[1], 5); /* Key */
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out);
//
// Display NDAS device info
//
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, DeviceID, &dwUnitNo), out);
_tprintf(L"DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
//
// Set Mac address
//
_ftprintf(stderr, _T("Applying setting to the device...\n"));
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
param_vcmd.SET_LPX_ADDRESS.AddressLPX[0] = (BYTE)MacAddressSegs[0];
param_vcmd.SET_LPX_ADDRESS.AddressLPX[1] = (BYTE)MacAddressSegs[1];
param_vcmd.SET_LPX_ADDRESS.AddressLPX[2] = (BYTE)MacAddressSegs[2];
param_vcmd.SET_LPX_ADDRESS.AddressLPX[3] = (BYTE)MacAddressSegs[3];
param_vcmd.SET_LPX_ADDRESS.AddressLPX[4] = (BYTE)MacAddressSegs[4];
param_vcmd.SET_LPX_ADDRESS.AddressLPX[5] = (BYTE)MacAddressSegs[5];
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_lpx_address, ¶m_vcmd, NULL, 0, NULL, 0), out);
_ftprintf(stderr, _T("Resetting the device...\n"));
ZeroMemory(¶m_vcmd, sizeof(NDASCOMM_VCMD_PARAM));
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_reset, ¶m_vcmd, NULL, 0, NULL, 0), out);
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
NdasCommUninitialize();
_ftprintf(stdout, _T("Finished the operation.\n"));
return GetLastError();
}
static void
gdk_window_postmove (GdkWindow *window,
GdkWindowParentPos *parent_pos,
gboolean anti_scroll)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkWin32PositionInfo new_info;
GList *tmp_list;
gint d_xoffset, d_yoffset;
GdkWindowParentPos this_pos;
GdkRegion *new_clip_region;
obj = (GdkWindowObject *) window;
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
gdk_window_compute_position (impl, parent_pos, &new_info);
new_clip_region =
gdk_window_clip_changed (window, &impl->position_info.clip_rect, &new_info.clip_rect);
this_pos.x = parent_pos->x + obj->x;
this_pos.y = parent_pos->y + obj->y;
this_pos.win32_x = parent_pos->win32_x + new_info.x;
this_pos.win32_y = parent_pos->win32_y + new_info.y;
this_pos.clip_rect = new_info.clip_rect;
if (impl->position_info.mapped && !new_info.mapped)
ShowWindow (GDK_WINDOW_HWND (window), SW_HIDE);
d_xoffset = new_info.x_offset - impl->position_info.x_offset;
d_yoffset = new_info.y_offset - impl->position_info.y_offset;
if (anti_scroll || (anti_scroll = d_xoffset != 0 || d_yoffset != 0))
{
GDK_NOTE (MISC, g_print ("gdk_window_postmove: %s@%+d%+d\n"
"... SetWindowPos(%p,NULL,%d,%d,0,0,"
"NOREDRAW|NOZORDER|NOACTIVATE|NOSIZE)\n",
_gdk_win32_drawable_description (window),
obj->x, obj->y,
GDK_WINDOW_HWND (window),
new_info.x, new_info.y));
API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
new_info.x, new_info.y,
0, 0,
SWP_NOREDRAW | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE));
}
if (!impl->position_info.mapped && new_info.mapped && GDK_WINDOW_IS_MAPPED (obj))
ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWNA);
if (impl->position_info.no_bg)
gdk_window_tmp_reset_bg (window);
impl->position_info = new_info;
if (new_clip_region)
gdk_window_post_scroll (window, new_clip_region);
tmp_list = obj->children;
while (tmp_list)
{
gdk_window_postmove (tmp_list->data, &this_pos, anti_scroll);
tmp_list = tmp_list->next;
}
}
/*
main function
returns non-zero if any function fails.
*/
int __cdecl wmain( int argc, wchar_t *argv[ ], wchar_t *envp[ ] )
{
BOOL bResult;
DWORD dwError = 0;
DWORD i;
DWORD dwVersion;
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BYTE DeviceID[6];
DWORD dwUnitNo;
PBYTE Buffer;
DWORD dwBufferLen;
BYTE data[512]; /* 1 sector sized buffer */
INT64 i64Location;
UINT ui64SectorCount;
NDASCOMM_IDE_REGISTER IdeRegister;
BYTE pbData[8];
DWORD cbData = sizeof(pbData);
NDASCOMM_VCMD_PARAM param_vcmd;
UINT32 uiTimeValue;
BOOL bEnableTimer;
NDAS_DEVICE_HARDWARE_INFO dinfo;
BYTE vid;
/* simple check parameter */
if(2 != argc)
{
wprintf(
L"usage : apitest.exe ID-KEY\n"
L"\n"
L"ID-KEY : 20 chars of id and 5 chars of key of the NDAS Device ex(01234ABCDE56789FGHIJ13579)\n"
L"ex : apitest.exe 01234ABCDE56789FGHIJ13579\n"
);
wprintf(L"\n");
return -1;
}
wprintf(L"\n\n\n* Start NDASComm API test on the NDAS Device : %s\n", argv[1]);
wprintf(L"* Initialize NdasComm library : NdasCommInitialize()\n");
API_CALL(NdasCommInitialize());
wprintf(L"* Get API Version : NdasCommGetAPIVersion()\n");
API_CALL_JMP(dwVersion = NdasCommGetAPIVersion(), out);
wprintf(L"- Version : Major %d, Minor %d\n",
(int)LOWORD(dwVersion), (int)HIWORD(dwVersion));
//////////////////////////////////////////////////////////////
//#define TEST_SET_PASSWORD
#ifdef TEST_SET_PASSWORD
wprintf(L"### TESTING 'Set user password' ###\n");
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_IDW; /* wide char set */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = TRUE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
CopyMemory(
ci.OEMCode.Bytes,
NdasOemCodeX1,
sizeof(NdasOemCodeX1)); /* HASH_KEY_USER_X1 */ /* Use default password */
CopyMemory(
ci.PrivilegedOEMCode.Bytes,
NdasPrivOemCodeX1,
sizeof(NdasPrivOemCodeX1)); /* HASH_KEY_SUPER_X1 */ /* Log in as super user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
wcsncpy(ci.NdasIdW.Id, argv[1], 20); /* ID */
wcsncpy(ci.NdasIdW.Key, argv[1] +20, 5); /* Key */
wprintf(L"* Connect to the NDAS Device : NdasCommConnect()\n");
API_CALL_JMP(
hNDAS = NdasCommConnect(
&ci,
0 /* synchronous mode */,
NULL /* no connection hint */
),
out);
wprintf(L"* Setting user password : NdasCommVendorCommand()\n");
*(UINT64 *)param_vcmd.SET_SUPERVISOR_PW.SupervisorPassword = HASH_KEY_SUPER_X1;
bResult = NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_supervisor_pw, ¶m_vcmd, NULL, 0, NULL, 0);
if(!bResult)
{
if(NDASCOMM_ERROR_HARDWARE_UNSUPPORTED != GetLastError())
{
API_CALL_JMP(FALSE && "NdasCommVendorCommand", out);
}
wprintf(L"- Not supported for this Hardware version\n");
}
*(UINT64 *)param_vcmd.SET_USER_PW.UserPassword = HASH_KEY_USER_X1;
bResult = NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_user_pw, ¶m_vcmd, NULL, 0, NULL, 0);
if(!bResult)
{
if(NDASCOMM_ERROR_HARDWARE_UNSUPPORTED != GetLastError())
{
API_CALL_JMP(FALSE && "NdasCommVendorCommand", out);
}
wprintf(L"- Not supported for this Hardware version\n");
}
#define TEST_SET_PASSWORD_RESET
#ifdef TEST_SET_PASSWORD_RESET
wprintf(L"* Resetting : NdasCommVendorCommand()\n");
bResult = NdasCommVendorCommand(hNDAS, ndascomm_vcmd_reset, ¶m_vcmd, NULL, 0, NULL, 0);
if(!bResult)
{
if(NDASCOMM_ERROR_HARDWARE_UNSUPPORTED != GetLastError())
{
API_CALL_JMP(FALSE && "NdasCommVendorCommand", out);
}
wprintf(L"- Not supported for this Hardware version\n");
}
#else
wprintf(L"* Disconnect the connection from the NDAS Device : NdasCommDisconnect()\n");
API_CALL_JMP(NdasCommDisconnect(hNDAS), out);
#endif //TEST_SET_PASSWORD_RESET
wprintf(L"### TESTED 'Set user passoword' ###\n");
#endif //TEST_SET_PASSWORD
//////////////////////////////////////////////////////////////
wprintf(L"* Initialize connection info to create connection to the NDAS Device\n");
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_NDAS_IDW; /* wide char set */
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = TRUE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
wcsncpy(ci.Address.NdasIdW.Id, argv[1], 20); /* ID */
wcsncpy(ci.Address.NdasIdW.Key, argv[1] + 20, 5); /* Key */
wprintf(L"* Connect to the NDAS Device : NdasCommConnect()\n");
API_CALL_JMP( hNDAS = NdasCommConnect(&ci), out );
wprintf(L"* Retrieve NDAS Device ID & unit number : NdasCommGetDeviceID()\n");
API_CALL_JMP(NdasCommGetDeviceID(hNDAS, NULL, DeviceID, &dwUnitNo, &vid), out);
wprintf(L"- DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)dwUnitNo);
wprintf(L"* Retrieve the address of the host attached to the NDAS Device : NdasCommGetHostAddress()\n");
API_CALL_JMP(NdasCommGetHostAddress(hNDAS, NULL, &dwBufferLen), out);
wprintf(L"- buffer length : %d\n", dwBufferLen);
Buffer = malloc(dwBufferLen);
API_CALL_JMP(NdasCommGetHostAddress(hNDAS, Buffer, &dwBufferLen), out);
wprintf(L"- Host Address : ");
for(i = 0 ; i < dwBufferLen; i++)
{
wprintf(L"%02X", (UINT)Buffer[i]);
}
wprintf(L"\n");
free(Buffer);
ui64SectorCount = 1;
i64Location = 0;
wprintf(L"* Read %d sector(s) of data from Address %d : NdasCommBlockDeviceRead()\n",
ui64SectorCount, i64Location);
API_CALL_JMP(NdasCommBlockDeviceRead(hNDAS, i64Location, ui64SectorCount, data), out);
i64Location = 1;
wprintf(L"* Write %d sector(s) of data to Address %d : NdasCommBlockDeviceWriteSafeBuffer()\n",
ui64SectorCount, i64Location);
API_CALL_JMP(NdasCommBlockDeviceWriteSafeBuffer(hNDAS, i64Location, ui64SectorCount, data), out);
ui64SectorCount = 2;
i64Location = 2;
wprintf(L"* Verify %d sector(s) from Address %d : NdasCommBlockDeviceVerify()\n",
ui64SectorCount, i64Location);
API_CALL_JMP(NdasCommBlockDeviceVerify(hNDAS, i64Location, ui64SectorCount), out);
IdeRegister.command.command = 0xEC; /* WIN_IDENTIFY */
IdeRegister.device.dev = 0;
wprintf(L"* Identify the NDAS Unit Device : NdasCommIdeCommand()\n");
API_CALL_JMP(NdasCommIdeCommand(hNDAS, &IdeRegister, NULL, 0, data, 512), out);
/* data[] now has 512 bytes of identified data as per ANSI NCITS ATA6 rev.1b spec */
ZeroMemory(&dinfo, sizeof(NDAS_DEVICE_HARDWARE_INFO));
dinfo.Size = sizeof(NDAS_DEVICE_HARDWARE_INFO);
API_CALL_JMP(NdasCommGetDeviceHardwareInfo(hNDAS,&dinfo), out);
wprintf(L"Hardware Version : %d\n", dinfo.HardwareVersion);
wprintf(L"* get standby timer : NdasCommVendorCommand()\n");
bResult = NdasCommVendorCommand(hNDAS, ndascomm_vcmd_get_ret_time, ¶m_vcmd, NULL, 0, NULL, 0);
if(!bResult)
{
if(NDASCOMM_ERROR_HARDWARE_UNSUPPORTED != GetLastError())
{
API_CALL_JMP(FALSE && "NdasCommVendorCommand", out);
}
wprintf(L"- Not supported for this Hardware version\n");
}
else
{
uiTimeValue = param_vcmd.GET_STANDBY_TIMER.TimeValue;
bEnableTimer = param_vcmd.GET_STANDBY_TIMER.EnableTimer;
wprintf(L"- standby timer : %d, enable : %d\n", uiTimeValue, bEnableTimer);
param_vcmd.SET_STANDBY_TIMER.TimeValue = uiTimeValue;
param_vcmd.SET_STANDBY_TIMER.EnableTimer = bEnableTimer ? 0 : 1;
wprintf(L"* set standby timer : NdasCommVendorCommand()\n");
API_CALL_JMP(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_ret_time, ¶m_vcmd, NULL, 0, NULL, 0), out);
uiTimeValue = param_vcmd.SET_STANDBY_TIMER.TimeValue;
bEnableTimer = param_vcmd.SET_STANDBY_TIMER.EnableTimer;
wprintf(L"- standby timer : %d, enable : %d\n", uiTimeValue, bEnableTimer);
}
wprintf(L"* Disconnect the connection from the NDAS Device : NdasCommDisconnect()\n");
API_CALL_JMP(NdasCommDisconnect(hNDAS), out);
wprintf(L"* Uninitialize NDASComm API : NdasCommUninitialize()\n");
out:
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
API_CALL(NdasCommUninitialize());
return GetLastError();
}
BOOL
print_ndas_unitdevice_info(
const NDASCOMM_CONNECTION_INFO* pci)
{
BOOL success;
int i;
HNDAS hNdas = NULL;
NDAS_UNITDEVICE_HARDWARE_INFO uinfo;
NDASCOMM_IDE_REGISTER idereg;
struct hd_driveid ideInfo;
UINT64 sectors;
TCHAR szBuffer[100];
const DWORD cchBuffer = sizeof(szBuffer) / sizeof(szBuffer[0]);
/* NdasCommGetUnitDeviceStat requires NORMAL login type */
_ASSERTE(NDASCOMM_LOGIN_TYPE_NORMAL == pci->LoginType);
API_CALL_JMP(fail, hNdas = NdasCommConnect(pci));
/* Unit Device Information */
ZeroMemory(&uinfo, sizeof(NDAS_UNITDEVICE_HARDWARE_INFO));
uinfo.Size = sizeof(NDAS_UNITDEVICE_HARDWARE_INFO);
API_CALL_JMP(fail, NdasCommGetUnitDeviceHardwareInfo(hNdas, &uinfo));
sectors =
_tprintf(_T(" Sector count : %I64d\n"), uinfo.SectorCount.QuadPart);
_tprintf(_T(" Supports LBA : %s\n"), bool_string(uinfo.LBA));
_tprintf(_T(" Supports LBA48 : %s\n"), bool_string(uinfo.LBA48));
_tprintf(_T(" Supports PIO : %s\n"), bool_string(uinfo.PIO));
_tprintf(_T(" Supports DMA : %s\n"), bool_string(uinfo.DMA));
_tprintf(_T(" Supports UDMA : %s\n"), bool_string(uinfo.UDMA));
_tprintf(_T(" Model : %s\n"), uinfo.Model);
_tprintf(_T(" Firmware Rev : %s\n"), uinfo.FirmwareRevision);
_tprintf(_T(" Serial number : %s\n"), uinfo.SerialNumber);
_tprintf(_T(" Media type : %s\n"), media_type_string(uinfo.MediaType));
_tprintf(_T("\n"));
/* Additional IDE information using WIN_IDENTIFY command */
idereg.device.lba_head_nr = 0;
idereg.device.dev = (0 == pci->UnitNo) ? 0 : 1;
idereg.device.lba = 0;
idereg.command.command = WIN_IDENTIFY;
API_CALL_JMP(fail,
NdasCommIdeCommand(hNdas, &idereg, NULL, 0, (PBYTE)&ideInfo, sizeof(ideInfo)));
_tprintf(_T(" FLUSH CACHE : Supports - %s, Enabled - %s\n"),
bool_string(ideInfo.command_set_2 & 0x1000),
bool_string(ideInfo.cfs_enable_2 & 0x1000));
_tprintf(_T(" FLUSH CACHE EXT : Supports - %s, Enabled - %s\n"),
bool_string(ideInfo.command_set_2 & 0x2000),
bool_string(ideInfo.cfs_enable_2 & 0x2000));
/* Check Ultra DMA mode */
for (i = 7; i >= 0; i--)
{
if (ideInfo.dma_ultra & (0x01 << i))
{
_tprintf(_T(" Ultra DMA mode: supports up to UDMA mode %d\n"), i);
break;
}
}
for (i = 7; i >= 0; i--)
{
if (ideInfo.dma_ultra & (0x01 << (i + 8)))
{
_tprintf(_T(" Current Ultra DMA mode: %d\n"), i);
break;
}
}
if (i < 0)
{
_tprintf(_T(" Ultra DMA mode is not selected\n"));
}
/* Check DMA mode */
for (i = 2; i >= 0; i--)
{
if (ideInfo.dma_mword & (0x01 << i))
{
_tprintf(_T(" DMA mode: supports up to DMA mode %d\n"), i);
break;
}
}
for (i = 2; i >= 0; i--)
{
if (ideInfo.dma_mword & (0x01 << (i + 8)))
{
_tprintf(_T(" DMA mode %d selected\n"), i);
break;
}
}
if (i < 0)
{
_tprintf(_T(" DMA mode is not selected\n"));
}
_tprintf(_T("\n"));
success = TRUE;
fail:
if (hNdas)
{
API_CALL(NdasCommDisconnect(hNdas));
}
return success;
}
int
CpInfo(int argc, _TCHAR* argv[])
{
HNDAS hNDAS = NULL;
NDASCOMM_CONNECTION_INFO ci;
BOOL bResults;
NDAS_DEVICE_ID SrcAddr1;
NDASOP_RAID_INFO RaidInfo = {0};
PTCHAR str;
PTCHAR EmptyStr=_T("");
DWORD MemberCount;
DWORD i, j;
DWORD Flags;
PNDAS_OOS_BITMAP_BLOCK BmpBuffer = NULL;
//
// Get arguments.
//
if(argc < 1) {
_ftprintf(stderr, _T("ERROR: More parameter needed.\n"));
return -1;
}
_ftprintf(stderr, _T("RAID Info using %s as primary device \n"), argv[0]);
// Argv[0]: SrcAddr1
bResults = ConvertMacToNodeId(argv[0], &SrcAddr1);
if (!bResults) {
_ftprintf(stderr, _T("Invalid device ID.\n"));
return -1;
}
SrcAddr1.VID = 1; // to do: get VID as parameter
SetLastError(0);
API_CALL(NdasCommInitialize());
ZeroMemory(&ci, sizeof(ci));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_DEVICE_ID;
ci.UnitNo = 0; /* Use first Unit Device */
ci.WriteAccess = FALSE; /* Connect with read-write privilege */
ci.Protocol = NDASCOMM_TRANSPORT_LPX; /* Use LPX protocol */
ci.OEMCode.UI64Value = 0; /* Use default password */
ci.PrivilegedOEMCode.UI64Value = 0; /* Log in as normal user */
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL; /* Normal operations */
ci.Address.DeviceId = SrcAddr1;
ci.Address.DeviceId.VID = 1;
hNDAS = NdasCommConnect(&ci);
if (!hNDAS) {
_ftprintf(stdout, _T("Cannot connect\n"));
goto out;
}
//
// Get and dump RAID info
//
RaidInfo.Size = sizeof(RaidInfo);
bResults = NdasOpGetRaidInfo(hNDAS,&RaidInfo);
switch(RaidInfo.Type) {
case NMT_SINGLE: str=_T("Single"); break;
case NMT_MIRROR: str=_T("Mirror without repair info"); break;
case NMT_AGGREGATE: str=_T("Aggregation"); break;
case NMT_RAID0: str=_T("RAID0"); break;
case NMT_RAID1: str=_T("RAID1R1(~3.10)"); break;
case NMT_RAID4: str=_T("RAID4R1(~3.10)"); break;
case NMT_RAID1R2: str=_T("RAID1R2(3.11~)"); break;
case NMT_RAID4R2: str=_T("RAID4R2(3.11~)"); break;
case NMT_RAID1R3: str=_T("RAID1R3(3.20~)"); break;
case NMT_RAID4R3: str=_T("RAID4R3(3.20~)"); break;
case NMT_AOD: str=_T("Append only disk"); break;
case NMT_VDVD: str=_T("Virtual DVD"); break;
case NMT_CDROM: str=_T("packet device, CD / DVD"); break;
case NMT_OPMEM: str=_T("packet device, Magnetic Optical"); break;
case NMT_FLASH: str=_T("flash card"); break;
case NMT_CONFLICT: str=_T("DIB is conflicting"); break;
default: str=_T("Unknown"); break;
}
_ftprintf(stdout, _T("Type: %s\n"), str);
_ftprintf(stdout, _T("Mountability Flags: %x(%s%s%s%s%s%s)\n"), RaidInfo.MountablityFlags,
(RaidInfo.MountablityFlags & NDAS_RAID_MOUNTABILITY_UNMOUNTABLE)?_T("Unmountable "):EmptyStr,
(RaidInfo.MountablityFlags & NDAS_RAID_MOUNTABILITY_MOUNTABLE)?_T("Mountable "):EmptyStr,
(RaidInfo.MountablityFlags & NDAS_RAID_MOUNTABILITY_NORMAL)?_T("in normal mode "):EmptyStr,
(RaidInfo.MountablityFlags & NDAS_RAID_MOUNTABILITY_DEGRADED)?_T("in degraded mode "):EmptyStr,
(RaidInfo.MountablityFlags & NDAS_RAID_MOUNTABILITY_MISSING_SPARE)?_T("with missing spare"):EmptyStr,
(RaidInfo.MountablityFlags & NDAS_RAID_MOUNTABILITY_SPARE_EXIST)?_T("with spare"):EmptyStr
);
_ftprintf(stdout, _T("Fail reason: %x(%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n"), RaidInfo.FailReason,
(RaidInfo.FailReason == NDAS_RAID_FAIL_REASON_NONE)?_T("None"):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_RMD_CORRUPTED)?_T("RMD corrupted "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_MEMBER_OFFLINE)?_T("Offline "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_DIB_MISMATCH)?_T("DIB mismatch "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_SPARE_USED)?_T("Spare used "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_INCONSISTENT_DIB)?_T("Inconsistent DIB "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_UNSUPPORTED_DIB_VERSION)?_T("Unsupported DIB version "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_MIGRATION_REQUIRED)?_T("Migration required"):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_UNSUPPORTED_RAID)?_T("Unsupported RAID type"):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_DEFECTIVE)?_T("Defective disk "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_DIFFERENT_RAID_SET)?_T("RAID set ID mismatch "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_MEMBER_NOT_REGISTERED)?_T("Unregistered "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_MEMBER_IO_FAIL)?_T("IO failure "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_NOT_A_RAID)?_T("Not a RAID "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_IRRECONCILABLE)?_T("Irreconcilable "):EmptyStr,
(RaidInfo.FailReason & NDAS_RAID_FAIL_REASON_MEMBER_DISABLED)?_T("Disabled member "):EmptyStr
);
MemberCount = RaidInfo.MemberCount;
_ftprintf(stdout, _T("RAID Set ID = %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x\n"),
RaidInfo.RaidSetId.Data1, RaidInfo.RaidSetId.Data2, RaidInfo.RaidSetId.Data3,
RaidInfo.RaidSetId.Data4[0], RaidInfo.RaidSetId.Data4[1], RaidInfo.RaidSetId.Data4[2], RaidInfo.RaidSetId.Data4[3],
RaidInfo.RaidSetId.Data4[4], RaidInfo.RaidSetId.Data4[5], RaidInfo.RaidSetId.Data4[6], RaidInfo.RaidSetId.Data4[7]
);
_ftprintf(stdout, _T("Config Set ID= %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x\n"),
RaidInfo.ConfigSetId.Data1, RaidInfo.ConfigSetId.Data2, RaidInfo.ConfigSetId.Data3,
RaidInfo.ConfigSetId.Data4[0], RaidInfo.ConfigSetId.Data4[1], RaidInfo.ConfigSetId.Data4[2], RaidInfo.ConfigSetId.Data4[3],
RaidInfo.ConfigSetId.Data4[4], RaidInfo.ConfigSetId.Data4[5], RaidInfo.ConfigSetId.Data4[6], RaidInfo.ConfigSetId.Data4[7]
);
for(i=0;i<MemberCount;i++) {
_ftprintf(stdout, _T(" * Member %d - DeviceId %02x:%02x:%02x:%02x:%02x:%02x-%02x Unit %d\n"),
i,
RaidInfo.Members[i].DeviceId.Node[0], RaidInfo.Members[i].DeviceId.Node[1], RaidInfo.Members[i].DeviceId.Node[2],
RaidInfo.Members[i].DeviceId.Node[3], RaidInfo.Members[i].DeviceId.Node[4], RaidInfo.Members[i].DeviceId.Node[5],
RaidInfo.Members[i].DeviceId.VID, RaidInfo.Members[i].UnitNo
);
Flags = RaidInfo.Members[i].Flags;
_ftprintf(stdout, _T(" Flags: %x(%s%s%s%s%s%s%s%s%s%s%s%s%s)\n"),
Flags,
(Flags & NDAS_RAID_MEMBER_FLAG_ACTIVE)?_T("Active member "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_SPARE)?_T("Spare "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_ONLINE)?_T("Online "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_OFFLINE)?_T("Offline "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_DIFFERENT_RAID_SET)?_T("Different RAID Set ID "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_IO_FAILURE)?_T("IO failure "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_RMD_CORRUPTED)?_T("RMD corrupted "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_DIB_MISMATCH)?_T("DIB mismatch "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_OUT_OF_SYNC)?_T("Out-of-sync "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_BAD_SECTOR)?_T("Bad sector "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_BAD_DISK)?_T("Bad disk "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_REPLACED_BY_SPARE)?_T("Replaced by spare "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_IRRECONCILABLE)?_T("Irreconcilable "):EmptyStr,
(Flags & NDAS_RAID_MEMBER_FLAG_NOT_REGISTERED)?_T("Unregistered "):EmptyStr
);
}
// Dump Bitmap info.
if (RaidInfo.Type == NMT_RAID1R3) {
NDAS_DIB_V2 DIB_V2;
UINT32 OnBitCount;
UINT32 BitCount;
UINT32 BmpSectorCount;
UINT32 CurBitCount;
UCHAR OnBits[] = {1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7};
UINT32 BitOn, BitOnStart, BitOnEnd;
bResults = NdasCommBlockDeviceRead(
hNDAS,
NDAS_BLOCK_LOCATION_DIB_V2,
1,
(PBYTE)&DIB_V2);
if (!bResults) {
goto out;
}
BitCount = (UINT32)((DIB_V2.sizeUserSpace + DIB_V2.iSectorsPerBit - 1)/DIB_V2.iSectorsPerBit);
BmpSectorCount = (BitCount + NDAS_BIT_PER_OOS_BITMAP_BLOCK -1)/NDAS_BIT_PER_OOS_BITMAP_BLOCK;
OnBitCount = 0;
_ftprintf(stdout, _T("Bitmap sector per bit=0x%x, Bit count =0x%x, BmpSector count=0x%x\n"),
DIB_V2.iSectorsPerBit, BitCount, BmpSectorCount);
BmpBuffer = (PNDAS_OOS_BITMAP_BLOCK) malloc(BmpSectorCount* 512);
bResults =NdasCommBlockDeviceRead(hNDAS, NDAS_BLOCK_LOCATION_BITMAP, BmpSectorCount, (PBYTE)BmpBuffer);
if (!bResults) {
_ftprintf(stdout, _T("Failed to read BMP.\n"));
goto out;
}
CurBitCount = 0;
for(i=0;i<BmpSectorCount;i++) {
_ftprintf(stdout, _T(" Bitmap sector %d, Seq head=%I64x, tail=%I64x\n"), i, BmpBuffer[i].SequenceNumHead,BmpBuffer[i].SequenceNumTail);
BitOn = FALSE;
BitOnStart = BitOnEnd = 0;
for(j=0;j<NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8;j++) {
if (BitOn == FALSE && (BmpBuffer[i].Bits[j/8] & OnBits[j%8])) {
BitOn = TRUE;
BitOnStart = i * NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8 + j;
_ftprintf(stdout, _T(" Bit on from bit %x ~ "), BitOnStart);
}
if (BitOn == TRUE && (BmpBuffer[i].Bits[j/8] & OnBits[j%8]) == 0) {
BitOn = FALSE;
BitOnEnd = i * NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8 + j;
_ftprintf(stdout, _T("%x\n"), BitOnEnd-1);
}
if (BmpBuffer[i].Bits[j/8] & OnBits[j%8])
OnBitCount++;
CurBitCount++;
if (CurBitCount >= BitCount)
break;
}
if (BitOn == TRUE) {
_ftprintf(stdout, _T("%x\n"), i * NDAS_BYTE_PER_OOS_BITMAP_BLOCK * 8 + j);
}
}
_ftprintf(stdout, _T("%d bit is on out of %d bits. %.1lf%% out-of-sync.\n"), OnBitCount, BitCount, ((double)OnBitCount)/BitCount*100);
}
out:
if(GetLastError()) {
_ftprintf(stdout, _T("Error! Code:%08lx\n"), GetLastError());
}
if(hNDAS)
{
NdasCommDisconnect(hNDAS);
hNDAS = NULL;
}
if (BmpBuffer)
{
free(BmpBuffer);
}
NdasCommUninitialize();
return GetLastError();
}
/*
main function
returns non-zero if any function fails.
*/
int __cdecl main(int argc, char *argv[])
{
DWORD dwError = 0;
BOOL bResult;
HNDAS hNdas;
BYTE data[512]; // 1 sector sized buffer
// simple check parameter
if(2 != argc)
{
printf(
"usage : apitest.exe ID-KEY\n"
"\n"
"ID-KEY : 20 chars of id and 5 chars of key of the NDAS Device ex(01234ABCDE56789FGHIJ13579)\n"
"ex : apitest.exe 01234ABCDE56789FGHIJ13579\n"
);
printf("\n");
return -1;
}
printf("\n\n\n* Start NDASComm API test on the NDAS Device : %s\n", argv[1]);
printf("* Initialize NdasComm library : NdasCommInitialize()\n");
API_CALL(NdasCommInitialize());
DWORD dwVersion;
printf("* Get API Version : NdasCommGetAPIVersion()\n");
API_CALL(dwVersion = NdasCommGetAPIVersion());
printf("- Version : Major %d, Minor %d\n",
(int)LOWORD(dwVersion), (int)HIWORD(dwVersion));
printf("* Initialize connection info to create connection to the NDAS Device\n");
NDASCOMM_CONNECTION_INFO ci;
ZeroMemory(&ci, sizeof(ci));
ci.address_type = NDASCOMM_CONNECTION_INFO_TYPE_ID_A; // ASCII char set
ci.UnitNo = 0; // Use first Unit Device
ci.bWriteAccess = TRUE; // Connect with read-write privilege
ci.protocol = NDASCOMM_TRANSPORT_LPX; // Use LPX protocol
ci.ui64OEMCode = 0; // Use default password
ci.bSupervisor = FALSE; // Log in as normal user
ci.login_type = NDASCOMM_LOGIN_TYPE_NORMAL; // Normal operations
strncpy(ci.DeviceIDA.szDeviceStringId, argv[1], 20); // ID
strncpy(ci.DeviceIDA.szDeviceStringKey, argv[1] +20, 5); // Key
HNDAS hNDAS;
printf("* Connect to the NDAS Device : NdasCommConnect()\n");
API_CALL(
hNDAS = NdasCommConnect(
&ci,
0 /* synchronous mode */,
NULL /* no connection hint */
)
);
BYTE DeviceID[6];
DWORD UnitNo;
printf("* Retrieve NDAS Device ID & unit number : NdasCommGetDeviceID()\n");
API_CALL(NdasCommGetDeviceID(hNDAS, DeviceID, &UnitNo));
printf("- DeviceID : %02X%02X%02X%02X%02X%02X, Unit No. : %d\n",
DeviceID[0], DeviceID[1], DeviceID[2], DeviceID[3], DeviceID[4], DeviceID[5],
(int)UnitNo);
PBYTE Buffer;
DWORD BufferLen;
printf("* Retrieve the address of the host attached to the NDAS Device : NdasCommGetHostAddress()\n");
API_CALL(NdasCommGetHostAddress(hNDAS, NULL, &BufferLen));
printf("- buffer length : %d\n", BufferLen);
Buffer = new BYTE[BufferLen];
API_CALL(NdasCommGetHostAddress(hNDAS, Buffer, &BufferLen));
printf("- Host Address : ");
for(DWORD i = 0 ; i < BufferLen; i++)
{
printf("%02X", (UINT)Buffer[i]);
}
printf("\n");
delete [] Buffer;
INT64 i64Location;
UINT ui64SectorCount;
ui64SectorCount = 1;
i64Location = 0;
printf("* Read %d sector(s) of data from Address %d : NdasCommBlockDeviceRead()\n",
ui64SectorCount, i64Location);
API_CALL(NdasCommBlockDeviceRead(hNDAS, i64Location, ui64SectorCount, data));
i64Location = 1;
printf("* Write %d sector(s) of data to Address %d : NdasCommBlockDeviceWriteSafeBuffer()\n",
ui64SectorCount, i64Location);
API_CALL(NdasCommBlockDeviceWriteSafeBuffer(hNDAS, i64Location, ui64SectorCount, data));
ui64SectorCount = 2;
i64Location = 2;
printf("* Verify %d sector(s) from Address %d : NdasCommBlockDeviceVerify()\n",
ui64SectorCount, i64Location);
API_CALL(NdasCommBlockDeviceVerify(hNDAS, i64Location, ui64SectorCount));
NDASCOMM_IDE_REGISTER IdeRegister;
IdeRegister.command.command = 0xEC; // WIN_IDENTIFY
printf("* Identify the NDAS Unit Device : NdasCommIdeCommand()\n");
API_CALL(NdasCommIdeCommand(hNDAS, &IdeRegister, NULL, 0, data, 512));
// data[] now has 512 bytes of identified data as per ANSI NCITS ATA6 rev.1b spec
BYTE pbData[8];
const DWORD cbData = sizeof(pbData);
API_CALL(NdasCommGetDeviceInfo(hNDAS,ndascomm_handle_info_hw_version, pbData, cbData));
printf("Hardware Version : %d\n", *(BYTE*)pbData);
NDASCOMM_VCMD_PARAM param_vcmd;
printf("* get standby timer : NdasCommVendorCommand()\n");
bResult = NdasCommVendorCommand(hNDAS, ndascomm_vcmd_get_ret_time, ¶m_vcmd, NULL, 0, NULL, 0);
if(!bResult)
{
if(NDASCOMM_ERROR_HARDWARE_UNSUPPORTED != ::GetLastError())
{
API_CALL(FALSE && "NdasCommVendorCommand");
}
printf("- Not supported for this Hardware version\n");
}
else
{
UINT32 TimeValue = param_vcmd.GET_STANDBY_TIMER.TimeValue;
BOOL EnableTimer = param_vcmd.GET_STANDBY_TIMER.EnableTimer;
printf("- standby timer : %d, enable : %d\n", TimeValue, EnableTimer);
param_vcmd.SET_STANDBY_TIMER.TimeValue = TimeValue;
param_vcmd.SET_STANDBY_TIMER.EnableTimer = EnableTimer ? 0 : 1;
printf("* set standby timer : NdasCommVendorCommand()\n");
API_CALL(NdasCommVendorCommand(hNDAS, ndascomm_vcmd_set_ret_time, ¶m_vcmd, NULL, 0, NULL, 0));
TimeValue = param_vcmd.SET_STANDBY_TIMER.TimeValue;
EnableTimer = param_vcmd.SET_STANDBY_TIMER.EnableTimer;
printf("- standby timer : %d, enable : %d\n", TimeValue, EnableTimer);
}
printf("* Disconnect the connection from the NDAS Device : NdasCommDisconnect()\n");
API_CALL(NdasCommDisconnect(hNDAS));
printf("* Uninitialize NDASComm API : NdasCommUninitialize()\n");
API_CALL(NdasCommUninitialize());
return 0;
}
