void Destroy()
{
ReleaseDevice(&quad);
ReleaseDevice(&g_pInDevice);
ReleaseDevice(&g_pDIN);
ReleaseDevice(&g_pDevice);
ReleaseDevice(&g_pD3D);
delete[] map;
}
/****************************************************************************
Description:
Clean up the module if unloaded.
Arguments:
None.
Return Value:
None.
Remarks:
Called by the kernel.
****************************************************************************/
static void __exit duslic_module_exit(void)
{
IFX_int32_t i;
#ifdef CONFIG_DEVFS_FS
IFX_int32_t j;
#endif /* CONFIG_DEVFS_FS */
for (i=0; i < DUSLIC_MAX_DEVICES; i++)
{
#ifdef CONFIG_DEVFS_FS
/* remove duslic devices from dev fs */
for (j = 0; j <= DUSLIC_MAX_CHANNELS; j++ )
{
if (devfs_handle[i*DUSLIC_MAX_CHANNELS + j])
{
//printk("unregister dus%d%d\n",i+1,j);
devfs_unregister (devfs_handle[i*DUSLIC_MAX_CHANNELS + j]);
}
}
#else
unregister_chrdev (DUSLIC_MAJOR, DEV_NAME);
#endif /* CONFIG_DEVFS_FS */
}
for (i=0; i < DUSLIC_MAX_DEVICES; i++)
{
if (pDuslic_Devices[i] != NULL)
{
ReleaseDevice (pDuslic_Devices[i]);
}
}
remove_proc_entry(DEV_NAME,NULL);
}
void Shutdown()
{
Input::Shutdown();
Sprites::Shutdown();
ReleaseDevice();
}
bool SPDevice::ResetDevice( SPConfig config )
{
//SPTextureManager::GetSingleton().Unload();
// Try to reset.
if (d3dDevice)
{
if (D3D_OK == d3dDevice->Reset(&config.ToD3DParameters()))
{
return true;
}
}
// Force reload.
SPLogHelper::WriteLog("[DirectX] WARNING: Force reseting D3D device!");
ReleaseDevice();
if( !CreateD3DDevice(config) )
{
return false;
}
return true;
}
void CDirectInputDetail::Kill(void)
{
szInstanceName.Kill();
szProductName.Kill();
szID.Kill();
ReleaseDevice();
CNativeDetail::Kill();
}
CAMARO_API void ReleaseDeviceList(HDevice *list, int num)
{
if (list != nullptr)
{
for (auto i = 0; i < num; ++i)
ReleaseDevice(list+i);
delete[] list;
}
}
int main(int argc, char *argv[])
{
assert(argc == 2);
char * outFileName = argv[1];
FILE *outFile = fopen(outFileName, "w");
int dtFlyPinitStatus = InitDevice(userIntHandler);
assert(dtFlyPinitStatus == 0);
int status;
/*
uint32_t regData[1];
uint32_t regAddress = 513;
// Read, write, then read again register 0
// ReadWriteConfigRegs(direction, registerNumber, registerDataBuffer, numberOfRegisters)
status = ReadWriteConfigRegs(READ, regAddress, regData, 1);
printf("Read status is %d, value is %08lx\n", status, regData[0]);
regData[0] = 0x12345678;
status = ReadWriteConfigRegs(WRITE, regAddress, regData, 1);
printf("Write status is %d\n", status);
status = ReadWriteConfigRegs(READ, regAddress, regData, 1);
printf("Read status is %d, value is %08lx\n", status, regData[0]);
*/
/*
* Read and dump to file
*/
SBufferInit buffer;
unsigned bufferIndex = 0;
AllocateBuffer(bufferIndex, &buffer);
for(int nReads = 0; nReads < 10; nReads += 1) {
status = ReceiveDMAbyBufIndex(DMA1, bufferIndex, 1);
if(status > 0) {
uint64_t *wordBuffer = (uint64_t *)buffer.UserAddr;
int nWords = status / sizeof(uint64_t);
for(int i = 0; i < nWords; i++) {
fprintf(outFile, "%016llx\n", wordBuffer[i]);
}
}
}
ReleaseBuffer(bufferIndex);
ReleaseDevice();
fclose(outFile);
return 0;
}
bool OpenAL::CreateDevice()
{
ReleaseDevice();
m_Device = alcOpenDevice(NULL);
if(m_Device)
LogInfo("Opened OAL device");
return m_Device != NULL;
}
void OpenAL::Release()
{
LogInfo("Releasing OAL");
if(m_ActiveBuffers != 0 || m_ActiveSources != 0)
{
LogError("Fatal OAL error: hanging references detected, %i buffers, %i sources", m_ActiveBuffers, m_ActiveSources);
}
ReleaseDevice();
}
// release our DirectInput effects and devices, our DirectInput handle, and then unload dinput library
void FreeDirectInput ()
{
int i;
// release effects
for( i = 0; i < ARRAYSIZE( g_apdiEffect ); ++i )
ReleaseEffect( g_apdiEffect[i] );
ZeroMemory( g_apdiEffect, sizeof(g_apdiEffect) );
// release FF devices
for( i = 0; i << ARRAYSIZE(g_apFFDevice); ++i )
ReleaseDevice( g_apFFDevice[i] );
ZeroMemory( g_apFFDevice, sizeof(g_apFFDevice) );
// release normal devices
for( i = 0; i < g_nDevices; i++ )
ReleaseDevice( g_devList[i].didHandle );
ZeroMemory( g_devList, sizeof(g_devList) );
g_nDevices = 0;
// release mouse device
ReleaseDevice( g_sysMouse.didHandle );
ZeroMemory( &g_sysMouse, sizeof(g_sysMouse) );
// Release any DirectInput handles.
if( g_pDIHandle != NULL )
{
g_pDIHandle->Release();
g_pDIHandle = NULL;
}
// Unload the library.
if( g_hDirectInputDLL != NULL )
{
FreeLibrary( g_hDirectInputDLL );
g_hDirectInputDLL = NULL;
}
return;
}
int main(int ac, char **av)
{
int succp = 1;
Progname = av[0];
AlienFxHandle_t fx = {0,}; // relying on the compiler to obviate memset.
int ai = 1;
while(av[ai] && ('-' == av[ai][0]) && (1 < strlen(av[ai]))) {
// a simple "-" is handled later
if( ! strcmp("-v", av[ai])) verbose = 1;
else if( ! strcmp("-d", av[ai])) debug = 1;
else if( ! strcmp("-h", av[ai])) { Syntax(stdout); return 0; }
else { Syntax(stderr); return -1; }
++ai;
}
if(ai >= ac) { Syntax(stderr); return -1; }
if(InitDevice(AlienFxTypes, &fx))
{
int block = BLOCK_AC_POWER; // int block = BLOCK_LOAD_ON_BOOT;
SetDelay(fx.usb_handle, MIN_SPEED);
if(av[ai] && ! strcmp("-", av[ai])) // read from stdin
{
char *line = 0;
while(line = Fgetstr(stdin, "\n")) {
char **cmdv = 0;
if(cmdv = Stoss(" \t", line)) {
succp = Command( & fx, cmdv);
free(cmdv);
}
free(line);
}
return succp;
} else { // r g b hex-region...
succp = Command( & fx, & av[ai]);
}
ReleaseDevice( & fx);
} else
fputs("No recognized AlienFX device found.\n", stderr);
return succp ? 0 : -1;
}
SPDevice::~SPDevice(void)
{
ReleaseDevice();
}
~Implementation()
{
ReleaseDevice();
}
/**
Handle incomming frames from the serial port.
*/
void rxhandler(void) {
switch (serRxBuf.header.type) {
case ACK:
case NACK:
break;
case T_CONNECT: //connect JTAG to the target
InitTarget();
if (GetDevice() == STATUS_OK) {
txACK();
//printf("Device type: %04x\n", DEVICE);
} else{
txNACKstr("no target");
}
break;
case T_RELEASE: //release JTAG from target
ClrTCLK();
IR_Shift(IR_CNTRL_SIG_16BIT);
DR_Shift16(0x3001); //lch
IR_Shift(IR_CNTRL_SIG_RELEASE);
SetTCLK();
ReleaseTarget();
txACK();
break;
case T_RESET: //reset the target and release JTAG
ReleaseDevice(V_RESET);
ReleaseTarget();
txACK();
break;
case T_PUC: //reset the target through JTAG, keep connection
ExecutePUC();
txACK();
break;
case T_MEMREAD: //ream memory from target
{ //use a new block for local vars
word size = serRxBuf.data.memread.size;
word address = serRxBuf.data.memread.address;
word offset;
txACK();
HaltCPU();
if (size > sizeof(serTxBuf.data.memdata.data)) {
size = sizeof(serTxBuf.data.memdata.data);
}
if (address <= 0xff) { //peripherals in bytemode
for (offset = 0; offset < size; offset++) {
serTxBuf.data.memdata.data[offset] = ReadMem(F_BYTE, address+offset);
}
} else { //peripherals in wordmode as well as RAM and Flash
address = address & 0xfffe; //startaddress has to be even!
for (offset = 0; offset < size/2; offset++) {
((word *)serTxBuf.data.memdata.data)[offset] = ReadMem(F_WORD, address+offset*2);
}
if (size & 1) {
//odd size, read last byte separate
//odd sizes on word-mode peripherals yield wrong results
//in the last word!!
serTxBuf.data.memdata.data[size-1] = ReadMem(F_BYTE, address+size-1);
}
}
serTxBuf.data.memdata.address = address;
serTxBuf.header.type = T_MEMDATA;
serTxBuf.header.size = 2+size;
sendMessage(&serTxBuf);
}
break;
case T_MEMWRITE: //write target memory (Peripherals, RAM, Flash)
{
word offset;
word size = serRxBuf.header.size - 2;
HaltCPU();
if ((serRxBuf.data.memwrite.address >= 0x100) &&
(serRxBuf.data.memwrite.address <= 0x1ff)) { //peripherals in wordmode
for (offset = 0; offset < size; offset+=2) {
WriteMem(F_WORD,
serRxBuf.data.memwrite.address+offset,
((word*)serRxBuf.data.memwrite.data)[offset/2]
);
}
} else if (serRxBuf.data.memwrite.address < 0x1000) { //ram + peripherals, bytemode
for (offset = 0; offset < size; offset++) {
WriteMem(F_BYTE,
serRxBuf.data.memwrite.address+offset,
serRxBuf.data.memwrite.data[offset]
);
}
} else { //flash memory, wordmode
WriteFLASH(serRxBuf.data.memwrite.address,
size/2,
(word *)serRxBuf.data.memwrite.data
);
}
txACK();
}
break;
case T_EXEC: //execute target program located at given address
ReleaseDevice(serRxBuf.data.exec.address);
txACK();
break;
case T_MEMERASE: //erase target flash (Segment, Main or All)
HaltCPU();
EraseFLASH(
serRxBuf.data.memerase.mode,
serRxBuf.data.memerase.address
);
txACK();
break;
case T_MCLK: //provide MCLKs, allows sort of single stepping
ClrTCLK();
IR_Shift(IR_CNTRL_SIG_16BIT);
DR_Shift16(0x3401); //lch
while (serRxBuf.data.step.numsteps--) {
SetTCLK();
ClrTCLK();
}
SetTCLK();
txACK();
break;
case MEMREAD: //host memory read
{
word size = serRxBuf.data.memread.size;
byte *address = (byte*)serRxBuf.data.memread.address;
word offset;
txACK();
if (size > sizeof(serTxBuf.data.memdata.data)) {
size = sizeof(serTxBuf.data.memdata.data);
}
if (address <= (byte *)0xff) { //bytemode
for (offset = 0; offset < size; offset++) {
serTxBuf.data.memdata.data[offset] = address[offset];
}
} else { //wordmode
address = (byte *)((word)address & 0xfffe); //startaddress has to be even!
size &= 0xfffe; //size has to be even
for (offset = 0; offset < size/2; offset++) {
((word *)serTxBuf.data.memdata.data)[offset] = ((word *)address)[offset];
}
}
serTxBuf.data.memdata.address = (word)address;
serTxBuf.header.type = MEMDATA;
serTxBuf.header.size = 2+size;
sendMessage(&serTxBuf);
}
break;
case MEMWRITE: //host memory write, used to download user programs
{
void *adr = (byte *)serRxBuf.data.memwrite.address;
word offset;
word size = serRxBuf.header.size - 2;
if ((adr >= (void *)0x100) && (adr <= (void *)0x1ff)) { //peripherals, wordmode
for (offset = 0; offset < size/2; offset++) {
((word *)adr)[offset] = ((word *)serRxBuf.data.memwrite.data)[offset];
}
txACK();
return;
}
if (adr < (void *)0x1000) { //ram + peripherals, bytemode
for (offset = 0; offset < size; offset++) {
((byte *)adr)[offset] = serRxBuf.data.memwrite.data[offset];
}
} else { //flash
flashWriteBlock(
serRxBuf.data.memwrite.data,
(void *)serRxBuf.data.memwrite.address,
size);
}
txACK();
}
break;
case MEMERASE: //erase one segemnt on host
flashErase((void *)serRxBuf.data.memerase.address);
txACK();
break;
//~ case MEMEXEC: //exec code on host
//~ serRxBuf.memexec.function(
//~ serRxBuf.memexec.arg1,
//~ serRxBuf.memexec.arg2
//~ );
//~ txACK();
//~ break;
case STARTBSL: //start BSL for firmware upgrade
txACK();
while((UTCTL0 & TXEPT) == 0) {} //wait until last byte is sent
FCTL3 = 0; //generate a flash key violation -> POR reset, see main()
break;
default:
txNACKstr("unknown command"); //serialComm error: unknown command
}
}
/****************************************************************************
Description:
Open the device.
- allocating internal memory for each new device
- allocating io memory
- initialize the device
- set up the interrupt
Arguments:
inode - pointer to the inode
filp - file pointer to be opened
Return Value:
IFX_SUCCESS or error code
Remarks:
None.
****************************************************************************/
static int DUSLIC_Open (struct inode *inode, struct file *filp)
{
DUSLIC_DEVICE *pDev = NULL;
DUSLIC_CHANNEL *pCh = NULL;
IFX_int32_t dev_num = 0;
IFX_int32_t ret = IFX_SUCCESS;
IFX_int32_t num = MINOR(inode->i_rdev);
IFX_char_t nCh = 0;
/* get device number */
dev_num = (num / DUSLIC_MINOR_BASE) - 1;
if ((dev_num >= DUSLIC_MAX_DEVICES) || (dev_num < 0))
{
printk("Warning: Driver only supports %d DUSLIC(s)\n\r",
DUSLIC_MAX_DEVICES);
ret = -ENODEV;
goto OPEN_ERROR;
}
/* check if first open on this device */
if (pDuslic_Devices[dev_num] == NULL)
{
/* Now allocate and initialize all data. */
if (Board_DevOpen (dev_num) == IFX_ERR)
{
ret = -ENODEV;
goto OPEN_ERROR;
}
}
//IFXOS_MutexLock (SemDrvIF);
pDev = pDuslic_Devices[dev_num];
/* increase in use count */
pDev->nInUse++;
nCh = num % DUSLIC_MINOR_BASE;
if (nCh == 0)
{
/* Save the device pointer */
filp->private_data = pDev;
}
else if (nCh > 0 && nCh <= 2)
{
/* Save the channel pointer */
pCh = filp->private_data = &pDev->pChannel [nCh - 1];
pCh->nChannel = nCh-1;
/* Check if the device is opened as a non-blocking one */
if (! (filp->f_flags & O_NONBLOCK))
{
/* set the CF_NONBLOCK channel specific flag for reading without
blocking */
/* writing to the device is implemented as non-blocking */
pCh->nFlags |= CF_NONBLOCK;
}
pCh->nFlags |= CF_NONBLOCK;
if (pCh->nInUse == 0)
{
ResetChMember (pCh);
}
pCh->nInUse++;
}
MOD_INC_USE_COUNT;
//IFXOS_MutexUnlock (SemDrvIF);
return IFX_SUCCESS;
OPEN_ERROR:
if (pDev != NULL)
{
printk("open error!\n");
ReleaseDevice(pDev);
TRACE (DUSLIC,DBG_LEVEL_HIGH, ("Open Error 0x%lX\n", pDev->err));
}
return ret;
}
/**
Open the device from kernel mode.
\param
nDev - index of the DUSLIC device
\param
nCh - index of the DUSLIC channel (1 = channel 0, ...)
\return
handle to device/channel or ERR on error
\remarks
If not already done this will
- allocate internal memory for each new device
- allocate io memory
- initialize the device
- set up the interrupt
*/
INT DUSLIC_OpenKernel(INT nDev, INT nCh)
{
DUSLIC_DEVICE *pDev = NULL;
DUSLIC_CHANNEL *pCh = NULL;
INT ret = ERR;
/* check the device number for the type 0 */
if ((nDev >= DUSLIC_MAX_DEVICES) || (nDev < 0))
{
TRACE (DUSLIC, DBG_LEVEL_NORMAL,
("Warning: Driver only supports %d DUSLIC(s)\n\r",
DUSLIC_MAX_DEVICES));
ret = -ENODEV;
goto OPEN_ERROR;
}
/* check if first open on this device */
if (pDuslic_Devices[nDev] == NULL)
{
/* Now allocate and initialize all data. This function will call
OS_InitDevice at first */
if (Board_DevOpen(nDev) == ERR)
{
ret = -ENODEV;
goto OPEN_ERROR;
}
}
//Sem_Lock(SemDrvIF);
pDev = pDuslic_Devices[nDev];
/* increase in use count */
pDev->nInUse++;
if (nCh == 0)
{
/* return the device pointer */
ret = (INT)pDev;
}
else
{
/* return the channel pointer */
pCh = &pDev->pChannel [nCh - 1];
pCh->nChannel = nCh-1;
if (pCh->nInUse == 0)
{
ResetChMember (pCh);
}
pCh->nInUse++;
ret = (INT)pCh;
}
/* increment module use counter */
MOD_INC_USE_COUNT;
TRACE (VINETIC, DBG_LEVEL_LOW,
("Open Kernel VINETIC device Nr. %d, channel %d\n\r", nDev, nCh));
//Sem_Unlock (SemDrvIF);
return ret;
OPEN_ERROR:
if (pDev != NULL)
{
ReleaseDevice(pDev);
TRACE (DUSLIC,DBG_LEVEL_HIGH, ("Open Kernel Error 0x%X\n", pDev->err));
}
Board_ResetPlatform();
return ret;
}
// **if passed an existing DirectInputDevice which matches gGuid
// unacquires it, and sets its cooperative level (reinitialize)
// **if the existing device does not match the passed gGuid, the existing device is released
// **if no device was passed or gGuid did not match
// searches for the controller matching gGuid in connected and available devices
// creates a DirectInputDevice
// sets its data format
// sets its cooperative level
// for joysticks, calls EnumSetObjectsAxis for each axis
// GetInputDevice always leaves the returned device in an UNACQUIRED state.
bool GetInputDevice( HWND hWnd, LPDIRECTINPUTDEVICE8 &lpDirectInputDevice, GUID gGuid, DWORD dwDevType, DWORD dwCooperativeLevel )
{
DebugWriteA("GetInputDevice: gGuid is {%08.8lX-%04.4hX-%04.4hX-%02.2X%02.2X-%02.2X%02.2X%02.2X%02.2X%02.2X%02.2X}\n", gGuid.Data1, gGuid.Data2, gGuid.Data3, gGuid.Data4[0], gGuid.Data4[1], gGuid.Data4[2], gGuid.Data4[3], gGuid.Data4[4], gGuid.Data4[5], gGuid.Data4[6], gGuid.Data4[7]);
if( lpDirectInputDevice != NULL)
{
DIDEVICEINSTANCE didDev;
didDev.dwSize = sizeof(DIDEVICEINSTANCE);
lpDirectInputDevice->GetDeviceInfo( &didDev );
if( didDev.guidInstance == gGuid )
{ // we've already gotten this device; unacquire it and initialize
DebugWriteA("GetInputDevice: already created, attempting to reinit\n");
lpDirectInputDevice->Unacquire();
lpDirectInputDevice->SetCooperativeLevel( hWnd, dwCooperativeLevel );
return true;
}
else
ReleaseDevice( lpDirectInputDevice );
}
HRESULT hResult;
LPCDIDATAFORMAT ppDiDataFormat = NULL;
bool Success = false;
switch( LOBYTE(dwDevType) )
{
case DI8DEVTYPE_KEYBOARD:
ppDiDataFormat = &c_dfDIKeyboard;
break;
case DI8DEVTYPE_MOUSE:
ppDiDataFormat = &c_dfDIMouse2;
break;
//case DI8DEVTYPE_GAMEPAD:
//case DI8DEVTYPE_JOYSTICK:
//case DI8DEVTYPE_DRIVING:
//case DI8DEVTYPE_1STPERSON:
//case DI8DEVTYPE_FLIGHT:
default: // assume everything else is a gamepad; probably not the best idea but it works
ppDiDataFormat = &c_dfDIJoystick;
break;
}
bool bDeviceAvailable = false;
VOID* aRef[2] = { &gGuid, &bDeviceAvailable };
// for each available device in our dwDevType category, run EnumIsDeviceAvailable with params "aRef"
g_pDIHandle->EnumDevices( DI8DEVCLASS_ALL, EnumIsDeviceAvailable, (LPVOID)aRef, DIEDFL_ATTACHEDONLY );
if( !bDeviceAvailable )
{
DebugWriteA("GetInputDevice: Device does not appear available\n");
return false;
}
hResult = g_pDIHandle->CreateDevice( gGuid, &lpDirectInputDevice, NULL );
if( SUCCEEDED( hResult ))
{
hResult = lpDirectInputDevice->SetDataFormat( ppDiDataFormat );
hResult = lpDirectInputDevice->SetCooperativeLevel( hWnd, dwCooperativeLevel );
Success = SUCCEEDED( hResult );
if (!Success)
{
DebugWriteA("GetInputDevice: SetCooperativeLevel failed\n");
}
}
else
DebugWriteA("GetInputDevice: CreateDevice failed\n");
if( Success && ( ppDiDataFormat == &c_dfDIJoystick ))
lpDirectInputDevice->EnumObjects( EnumSetObjectsAxis, lpDirectInputDevice, DIDFT_AXIS );
return Success;
}