static BOOL InitializeIST()
{
BOOL r;
gMfcIntrEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!gMfcIntrEvent) {
ERRORMSG(1, (L"Unable to create interrupt event"));
return(FALSE);
}
if (!CreateInterruptNotification()) {
ERRORMSG(1, (L"Unable to create interrupt notification"));
CloseHandle(gMfcIntrEvent);
return FALSE;
}
r = KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR,
&g_MfcIrq, sizeof(UINT32),
&g_MfcSysIntr, sizeof(UINT32),
NULL);
if (r != TRUE) {
ERRORMSG(1, (L"Failed to request sysintr value for MFC interrupt.\r\n"));
DeleteInterruptNotification();
CloseHandle(gMfcIntrEvent);
return FALSE;
}
r = InterruptInitialize(g_MfcSysIntr, gMfcIntrEvent, NULL, 0);
if (r != TRUE) {
ERRORMSG(1, (L"Unable to initialize output interrupt"));
DeleteInterruptNotification();
CloseHandle(gMfcIntrEvent);
return FALSE;
}
gMfcIntrThread = CreateThread((LPSECURITY_ATTRIBUTES)NULL,
0,
(LPTHREAD_START_ROUTINE)MFC_IntrThread,
0,
0,
NULL);
if (!gMfcIntrThread) {
ERRORMSG(1, (L"Unable to create interrupt thread"));
InterruptDisable(g_MfcSysIntr);
DeleteInterruptNotification();
CloseHandle(gMfcIntrEvent);
return FALSE;
}
// Bump up the priority since the interrupt must be serviced immediately.
CeSetThreadPriority(gMfcIntrThread, MFC_THREAD_PRIORITY_DEFAULT);
RETAILMSG(1, (L"MFC Interrupt has been initialized.\n"));
return TRUE;
}
SD_API_STATUS
CSDHCBase::Start()
{
SD_API_STATUS status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
m_fDriverShutdown = FALSE;
// allocate the interrupt event
m_hevInterrupt = CreateEvent(NULL, FALSE, FALSE,NULL);
if (NULL == m_hevInterrupt) {
goto EXIT;
}
// initialize the interrupt event
RETAILMSG(0,(_T("CSDHCBase::Start() m_dwSysIntr = %x\r\n"), m_dwSysIntr)); // jylee
if (!InterruptInitialize (m_dwSysIntr, m_hevInterrupt, NULL, 0)) {
goto EXIT;
}
m_fInterruptInitialized = TRUE;
// create the interrupt thread for controller interrupts
m_htIST = CreateThread(NULL, 0, ISTStub, this, 0, NULL);
if (NULL == m_htIST) {
goto EXIT;
}
for (DWORD dwSlot = 0; dwSlot < m_cSlots; ++dwSlot) {
PCSDHCSlotBase pSlot = GetSlot(dwSlot);
status = pSlot->Start();
if (!SD_API_SUCCESS(status)) {
goto EXIT;
}
}
// wake up the interrupt thread to check the slot
::SetInterruptEvent(m_dwSysIntr);
status = SD_API_STATUS_SUCCESS;
EXIT:
if (!SD_API_SUCCESS(status)) {
// Clean up
Stop();
}
RETAILMSG(0,(_T("CSDHCBase::-Start() status = %x\r\n"), status)); // jylee
return status;
}
BOOL
CPCIDisk::ConfigPort(
)
{
m_pATAReg = (PBYTE)m_pPort->m_dwRegBase;
m_pATARegAlt = (PBYTE)m_pPort->m_dwRegAlt;
m_pBMCommand = (PBYTE)m_pPort->m_dwBMR;
// this function is called for the master and slave on this channel; if
// this has already been called, then exit
if (m_pPort->m_hIRQEvent) {
m_dwDeviceFlags |= DFLAGS_DEVICE_INITIALIZED;
return TRUE;
}
// create interrupt event
if (NULL == (m_pPort->m_hIRQEvent = CreateEvent(NULL, FALSE, FALSE, NULL))) {
DEBUGMSG(ZONE_INIT|ZONE_ERROR, (_T(
"Atapi!CPCIDisk::ConfigPort> Failed to create interrupt event for device(%d)\r\n"
), m_dwDeviceId));
return FALSE;
}
// associate interrupt event with IRQ
if (!InterruptInitialize(
m_pPort->m_dwSysIntr,
m_pPort->m_hIRQEvent,
NULL,
0)
) {
DEBUGMSG(ZONE_INIT|ZONE_ERROR, (_T(
"Atapi!CPCIDisk::ConfigPort> Failed to initialize interrupt(SysIntr(%d)) for device(%d)\r\n"
), m_pPort->m_dwSysIntr, m_dwDeviceId));
return FALSE;
}
return TRUE;
}
BOOL CPdd6410Uart::Init()
{
BOOL bRet = TRUE;
if ( CSerialPDD::Init() && IsKeyOpened() && m_XmitFlushDone!=NULL)
{
// IST Setup .
DDKISRINFO ddi;
if (GetIsrInfo(&ddi)!=ERROR_SUCCESS)
{
bRet = FALSE;
goto CleanUp;
}
m_dwSysIntr = ddi.dwSysintr;
if (m_dwSysIntr != MAXDWORD && m_dwSysIntr!=0 )
{
m_hISTEvent= CreateEvent(0,FALSE,FALSE,NULL);
}
if (m_hISTEvent!=NULL)
{
InterruptInitialize(m_dwSysIntr,m_hISTEvent,0,0);
}
else
{
bRet = FALSE;
goto CleanUp;
}
// Get Device Index.
if (!GetRegValue(PC_REG_DEVINDEX_VAL_NAME, (PBYTE)&m_dwDevIndex, PC_REG_DEVINDEX_VAL_LEN))
{
m_dwDevIndex = 0;
}
if (!GetRegValue(PC_REG_SERIALWATERMARK_VAL_NAME,(PBYTE)&m_dwWaterMark,PC_REG_SERIALWATERMARKER_VAL_LEN))
{
m_dwWaterMark = DEFAULT_VALUE_WATER_MARK;
}
if (!GetRegValue(PC_REG_6410UART_IST_TIMEOUTS_VAL_NAME,(PBYTE)&m_dwISTTimeout, PC_REG_6410UART_IST_TIMEOUTS_VAL_LEN))
{
m_dwISTTimeout = INFINITE;
}
if (!GetRegValue(PC_REG_6410UART_MEM_LENGTH_VAL_NAME, (PBYTE)&m_dwMemLen, PC_REG_6410UART_MEM_LENGTH_VAL_LEN))
{
m_dwMemLen = DEFAULT_VALUE_MEM_LENGH;
}
if (!MapHardware() || !CreateHardwareAccess())
{
bRet = FALSE;
goto CleanUp;
}
#ifdef USE_DMA
if (!GetRegValue(PC_REG_TX_DMA_EN_NAME,(PBYTE)&m_dwTXDMAEnable, sizeof(DWORD)))
{
m_dwTXDMAEnable = FALSE;
}
if(m_dwTXDMAEnable)
{
RETAILMSG(1, (L"[UART] DMA init CH:%d \r\n", m_dwDevIndex));
InitializeDMA(m_dwDevIndex);
}
#endif
bRet = TRUE;
goto CleanUp;
}
bRet = FALSE;
CleanUp:
return bRet;
}
//=======================================================================
// LED_Init - Driver initialization function
//
DWORD LED_Init(LPCSTR pContext, DWORD dwBusContext){
PDRVCONTEXT pDrv;
RETAILMSG(RETAIL_ON, (TEXT("Test debug output without context \r\n")));
RETAILMSG(RETAIL_ON, (TEXT("LED_Init++ dwContext: %x\r\n"), pContext));
// Allocate a driver instance structure - required if we want to manage
// more instances
pDrv = (PDRVCONTEXT)LocalAlloc(LPTR, sizeof(DRVCONTEXT));
if(pDrv){
// initialize structure
memset((PBYTE) pDrv, 0, sizeof(DRVCONTEXT));
pDrv->dwSize = sizeof(DRVCONTEXT);
// read registry to determine the size of the disk
// GetConfigData((DWORD)pContext);
}else{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. Out of memory\r\n"), pContext));
}
DWORD dwGpio = 15;
DWORD dwIrq = 0;
DWORD dwEdge = GPIO_EDGE_RISING;
if (!KernelIoControl(IOCTL_HAL_GPIO2IRQ, &dwGpio, sizeof(DWORD), &dwIrq, sizeof(DWORD), NULL))
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. IOCTL_HAL_GPIO2IRQ\r\n"), pContext));
return 0;
}
if (!KernelIoControl(IOCTL_HAL_IRQEDGE, &dwIrq, sizeof(BYTE), &dwEdge, sizeof(BYTE), NULL))
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. IOCTL_HAL_IRQEDGE\r\n"), pContext));
return 0;
}
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIrq, sizeof(DWORD), &(pDrv->dwSysIntr), sizeof(DWORD), NULL))
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. IOCTL_HAL_REQUEST_SYSINTR\r\n"), pContext));
return 0;
}
pDrv->hEvent = CreateEvent(NULL, false, false, TEXT("ISTEvent"));
if (!(pDrv->hEvent))
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. Create Event failed.\r\n"), pContext));
return 0;
}
if (!InterruptInitialize(pDrv->dwSysIntr, pDrv->hEvent, NULL, 0))
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. InterruptInitialize failed.\r\n"), pContext));
return 0;
}
pDrv->hIsrHandle = LoadIntChainHandler(TEXT("\\Program Files\\Drivers\\ISRDll.dll"), TEXT("ISRHandler"), dwIrq);
if (!pDrv->hIsrHandle)
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. LoadIntChainHandler failed.\r\n"), pContext));
return 0;
}
isr_info.SysIntr = pDrv->dwSysIntr;
isr_info.pGPIORegs = (GPIOREG*)CreateStaticMapping(GPIO_BASE >> 8, sizeof(GPIOREG));
if (!isr_info.pGPIORegs)
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. CreateStaticMapping failed.\r\n"), pContext));
return 0;
}
if (!KernelLibIoControl(pDrv->hIsrHandle, IOCTL_ISR_INFO, &isr_info, sizeof(isr_info), NULL, 0, NULL))
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. IOCTL_HAL_RELEASE_SYSINTR failed.\r\n"), pContext));
return 0;
}
pDrv->hIntThread = CreateThread(NULL, 0, ISTFunction, pDrv->hEvent, 0, NULL);
if (!pDrv->hIntThread)
{
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init failure. CreateThread failed.\r\n"), pContext));
return 0;
}
RETAILMSG(RETAIL_ON, (DTAG TEXT("LED_Init-- pDrv: %x\r\n"), pDrv));
return (DWORD)pDrv;
FREECHAINHANDLER:
FreeIntChainHandler(pDrv->hIsrHandle);
INTERRUPTDISABLE:
InterruptDisable(pDrv->dwSysIntr);
KERNELIOCONTROL:
KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &pDrv->dwSysIntr, sizeof(DWORD), NULL, 0, NULL);
CLOSEHANDLE:
CloseHandle(pDrv->hEvent);
DELETESTATICMAPPING:
DeleteStaticMapping((LPVOID)isr_info.pGPIORegs, sizeof(GPIOREG));
}
int CameraInit(void *pData)
{
PHYSICAL_ADDRESS ioPhysicalBase = {0,0};
RETAILMSG(CAM_INOUT,(TEXT("++%s\n"), __FUNCTION__));
// 0. Map to Virtual Address
// GPIO Virtual alloc
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_GPIO;
s6410IOP = (S3C6410_GPIO_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_GPIO_REG), FALSE);
if (s6410IOP == NULL)
{
goto CleanUp;
}
// Camera Virtual alloc
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_CAMIF;
s6410CAM = (S3C6410_CAMIF_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_CAMIF_REG), FALSE);
if (s6410CAM == NULL)
{
goto CleanUp;
}
// PWM clock Virtual alloc
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_SYSCON;
s6410PWR = (S3C6410_SYSCON_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_SYSCON_REG), FALSE);
if (s6410PWR == NULL)
{
goto CleanUp;
}
hPwrControl = CreateFile( L"PWC0:", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (INVALID_HANDLE_VALUE == hPwrControl )
{
RETAILMSG(CAM_ERR, (TEXT("[CAM] CameraInit() : PWC0 Open Device Failed\r\n")));
return FALSE;
}
ModuleInit();
CameraSetClockDiv();
// 1. Camera IO setup
CameraGpioInit();
// 2. Camera Clock setup
CameraClockOn(TRUE);
// 3. camera module reset
CameraModuleReset();
/*
// Reserved Step
// 4. Write Setting for Module using I2C
if(!ModuleWriteBlock())
{
return FALSE;
}
// 5. Camera i/f reset
CameraInterfaceReset();
// 6. Initialize I/F source register
CameraCaptureSourceSet();
*/
// 7. Camera Clock Off
CameraClockOn(FALSE);
// 8. Allocation Buffer();
if(!InitializeBuffer())
{
return FALSE;
}
// 9. Interrupt Initlaize();
if(!InterruptInitialize())
{
return FALSE;
}
RETAILMSG(CAM_INOUT,(TEXT("--%s Succeeded\n"), __FUNCTION__));
return TRUE;
CleanUp:
RETAILMSG(1,(TEXT("%s : Failed, ioPhysicalBase(0x%x,0x%x)\r\n"), __FUNCTION__, ioPhysicalBase.LowPart, ioPhysicalBase.HighPart));
return FALSE;
}
BOOL KeyMatrix::IsrThreadProc()
{
DWORD dwPriority;
DWORD i, step;
DWORD rguiScanCode[SIZE_KEY];
BOOL rgfKeyUp[SIZE_KEY];
UINT cEvents;
DWORD ret;
DWORD timeout;
HANDLE gEventIntr;
DWORD irq, sysintr;
ReadRegDWORD( TEXT("HARDWARE\\DEVICEMAP\\KEYBD"), _T("Priority256"), &dwPriority );
if(dwPriority == 0)
{
dwPriority = DEFAULT_PRIORITY;
}
DEBUGMSG(ZONE_INIT, (TEXT("+[KEYBD]IsrThreadProc\r\n")));
// update the IST priority
CeSetThreadPriority(GetCurrentThread(), (int)dwPriority);
irq = IRQ_KEYPAD;
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &irq, sizeof(UINT32), &sysintr, sizeof(UINT32), NULL))
{
ERRORMSG( 1, (TEXT("ERROR: Failed to request the IRQ_KEY sysintr.\r\n")));
sysintr = SYSINTR_UNDEFINED;
return(FALSE);
}
gEventIntr = CreateEvent(NULL, FALSE, FALSE, NULL);
if( NULL == gEventIntr )
{
ERRORMSG( 1, (TEXT("Event is not created\r\n")));
return(FALSE);
}
if( InterruptInitialize(sysintr, gEventIntr, NULL, 0) == FALSE )
{
ERRORMSG( 1, (TEXT("interrupt is not initialized\n\r")));
return(FALSE);
}
timeout = INFINITE;
DEBUGMSG(ZONE_INIT, (TEXT("+[KEYBD]Enter Infinite Loop\r\n")));
while(1) // INFINITE LOOP ____________________________________________________________________
{
ret = WaitForSingleObject(gEventIntr, timeout); // Wait for Interrupt Event ________________________
if( ret == WAIT_OBJECT_0 )
{
RETAILMSG( FALSE,(TEXT("Object : WAIT_OBJECT_0\r\n")));
timeout = TIME_KEYSCAN;
}
// Clear Pressed/Released Interrupt
KEYIF_Status_Clear();
// Read the Matrix
KScan_ProcIO();
for( i=0, step=0; i< SIZE_COLS; i++, step+=SIZE_ROWS)
{
cEvents = KScan_ProcState( i, step, rguiScanCode, rgfKeyUp);
if( cEvents )
{
for (UINT iEvent = 0; iEvent < cEvents; ++iEvent)
{
v_pfnKeybdEvent(v_uiPddId, rguiScanCode[iEvent], rgfKeyUp[iEvent]);
RETAILMSG(FALSE,(TEXT("PddID : %x, ScanCode : %x, KeyUp : %d\r\n"),v_uiPddId, rguiScanCode[iEvent], rgfKeyUp[iEvent]));
}
}
}
if( TRUE == AreAllKeysUp() )
{
RETAILMSG(0,(TEXT("Key all up\r\n")));
timeout = INFINITE;
}
InterruptDone(sysintr);
}// INFINITE LOOP ____________________________________________________________________
}
//------------------------------------------------------------------------------
//
// Function: KPD_Init
//
// Called by device manager to initialize device.
//
DWORD KPD_Init(LPCTSTR szContext, LPCVOID pBusContext)
{
DWORD rc = (DWORD)NULL;
KPD_DEVICE *pDevice = NULL;
PHYSICAL_ADDRESS pa;
DEBUGMSG(ZONE_FUNCTION, (
L"+KPD_Init(%s, 0x%08x)\r\n", szContext, pBusContext
));
// Create device structure
pDevice = (KPD_DEVICE *)LocalAlloc(LPTR, sizeof(KPD_DEVICE));
if (pDevice == NULL) {
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: "
L"Failed allocate KDP driver structure\r\n"
));
goto cleanUp;
}
// Set cookie & initialize critical section
pDevice->cookie = KPD_DEVICE_COOKIE;
InitializeCriticalSection(&pDevice->cs);
// Read device parameters
if (GetDeviceRegistryParams(
szContext, pDevice, dimof(g_deviceRegParams), g_deviceRegParams
) != ERROR_SUCCESS) {
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: "
L"Failed read KPD driver registry parameters\r\n"
));
pDevice->irqs[0]= -1;
pDevice->irqs[1]= 2;
pDevice->irqs[2]=(DWORD)NULL;
pDevice->irqs[3]=(DWORD)NULL;
pDevice->irqs[4]=(DWORD)NULL;
pDevice->irqs[5]=(DWORD)NULL;
pDevice->irqs[6]=(DWORD)NULL;
pDevice->priority256=100;
pDevice->samplePeriod=40;
pDevice->debounceTime=0x50;
pDevice->firstRepeat=500;
pDevice->nextRepeat=125;
// goto cleanUp;
}
// map gpio memory space
pa.QuadPart = OMAP2420_GPIO1_REGS_PA;
pDevice->pGPIO1Regs = (OMAP2420_GPIO_REGS *) MmMapIoSpace(pa, sizeof(OMAP2420_GPIO_REGS), FALSE);
if (pDevice->pGPIO1Regs == NULL)
{
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: Failed to map GPIO1 registers\r\n"));
goto cleanUp;
}
pa.QuadPart = OMAP2420_GPIO2_REGS_PA;
pDevice->pGPIO2Regs = (OMAP2420_GPIO_REGS *) MmMapIoSpace(pa, sizeof(OMAP2420_GPIO_REGS), FALSE);
if (pDevice->pGPIO2Regs == NULL)
{
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: Failed to map GPIO2 registers\r\n"));
goto cleanUp;
}
pa.QuadPart = OMAP2420_GPIO3_REGS_PA;
pDevice->pGPIO3Regs = (OMAP2420_GPIO_REGS *) MmMapIoSpace(pa, sizeof(OMAP2420_GPIO_REGS), FALSE);
if (pDevice->pGPIO3Regs == NULL)
{
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: Failed to map GPIO3 registers\r\n"));
goto cleanUp;
}
pa.QuadPart = OMAP2420_GPIO4_REGS_PA;
pDevice->pGPIO4Regs = (OMAP2420_GPIO_REGS *) MmMapIoSpace(pa, sizeof(OMAP2420_GPIO_REGS), FALSE);
if (pDevice->pGPIO4Regs == NULL)
{
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: Failed to map GPIO4 registers\r\n"));
goto cleanUp;
}
// Need to configure the row GPIO's as interrupt sources
pDevice->irqs[0] = -1;
pDevice->irqs[1] = 2;
//pDevice->irqs[2] = IRQ_GPIO_0+88; // row 0 = GPIO88
//pDevice->irqs[3] = IRQ_GPIO_0+89; // row 1 = GPIO89
//pDevice->irqs[4] = IRQ_GPIO_0+124; // row 2 = GPIO124
//pDevice->irqs[5] = IRQ_GPIO_0+11; // row 3 = GPIO11
//pDevice->irqs[6] = IRQ_GPIO_0+6; // row 4 = GPIO6
// Map interrupts
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR,
pDevice->irqs, sizeof(pDevice->irqs),
&pDevice->sysIntr, sizeof(pDevice->sysIntr), NULL
)) {
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: "
L"Failed map Keyboard Interrupt\r\n"
));
goto cleanUp;
} else DEBUGMSG(ZONE_INIT, (L"KPD_Init: sysintr = %d",pDevice->sysIntr));
// Enable wakeup from keyboard if required
if (pDevice->enableWake != 0) {
DEBUGMSG(ZONE_ERROR, (L"Enable keyboard as wakeup source\r\n"));
if (!KernelIoControl(
IOCTL_HAL_ENABLE_WAKE, &pDevice->sysIntr, sizeof(pDevice->sysIntr),
NULL, 0, NULL
)) {
DEBUGMSG(ZONE_WARN, (L"WARN: KPD_Init: "
L"Failed enable keyboard as wakeup source\r\n"
));
}
}
// Create interrupt event
pDevice->hIntrEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (pDevice->hIntrEvent == NULL) {
DEBUGMSG(ZONE_ERROR, (L"ERROR: KPD_Init: "
L"Failed create interrupt event\r\n"
));
goto cleanUp;
}
// Initialize interrupt
if (!InterruptInitialize(pDevice->sysIntr, pDevice->hIntrEvent, NULL, 0)) {
DEBUGMSG (ZONE_ERROR, (L"ERROR: KPD_Init: "
L"InterruptInitialize failed\r\n"
));
goto cleanUp;
}
// Start interrupt service thread
if ((pDevice->hIntrThread = CreateThread(
NULL, 0, KPD_IntrThread, pDevice, 0,NULL
)) == NULL) {
DEBUGMSG (ZONE_ERROR, (L"ERROR: KPD_Init: "
L"Failed create interrupt thread\r\n"
));
goto cleanUp;
}
// Set thread priority
CeSetThreadPriority(pDevice->hIntrThread, pDevice->priority256);
// Return non-null value
rc = (DWORD)pDevice;
cleanUp:
if (rc == 0) KPD_Deinit((DWORD)pDevice);
DEBUGMSG(ZONE_FUNCTION, (L"-KPD_Init(rc = %d\r\n", rc));
return rc;
}
BOOL
CRomiDisk::Init(
HKEY hActiveKey
)
{
BOOL bRet = FALSE;
m_f16Bit = TRUE; // PCI is 16-bit
// configure port
if (!InitializePort()) {
DEBUGMSG(ZONE_INIT|ZONE_ERROR, (_T(
"Atapi!CRomiDisk::Init> Failed to configure port; device(%u)\r\n"
), m_dwDeviceId));
goto exit;
}
// assign the appropriate folder name
m_szDiskName = (IsCDRomDevice() ? g_szPCICDRomDisk : g_szPCIHardDisk);
// reserve memory for DMA buffers
m_pStartMemory = (LPBYTE)VirtualAlloc(NULL, 0x10000, MEM_RESERVE, PAGE_READWRITE);
if (!m_pStartMemory) {
bRet = FALSE;
}
WriteReg(ATA_CONTROL, ReadReg(ATA_CONTROL) | 0x1);
// finish intialization; i.e., initialize device
bRet = CDisk::Init(hActiveKey);
if ((m_pPort->m_pDskReg[m_dwDeviceId]->dwEnablePDMA || m_pPort->m_pDskReg[m_dwDeviceId]->dwEnableUDMA) && m_pDMAVirtualAddress == NULL)
{
DMA_ADAPTER_OBJECT dmaAdapter;
dmaAdapter.ObjectSize = sizeof(dmaAdapter);
dmaAdapter.InterfaceType = Internal;
dmaAdapter.BusNumber = 0;
m_pDMAVirtualAddress= (PBYTE)HalAllocateCommonBuffer( &dmaAdapter, m_pPort->m_pDskReg[m_dwDeviceId]->dwDoubleBufferSize, &m_DMAPhyaddress, FALSE );
}
if (m_pPort->m_pDskReg[m_dwDeviceId]->dwEnableUDMA && ( m_Id.UltraDMASupport & 0x3f))
{
for(int i=5;i>=0;i--) {
if(m_Id.UltraDMASupport & (0x01<<i)) {
m_dwCurrentUDMAMode = (i > 4) ? 4 : i;
break;
}
}
SetPioMode(PIO0);
SetUdmaMode();
DEBUGMSG(ZONE_INIT, (_T("### ATA-Disk supports UDMA to 0x%x 0x%x\r\n"), m_Id.UltraDMASupport,m_dwCurrentUDMAMode));
m_pPort->m_pDskReg[m_dwDeviceId]->dwEnablePDMA = FALSE;
}
else if (m_pPort->m_pDskReg[m_dwDeviceId]->dwEnablePDMA)
{
SetPioMode(m_Id.AdvancedPIOxferreserved);
m_pPort->m_pDskReg[m_dwDeviceId]->dwEnableUDMA = FALSE;;
DEBUGMSG(ZONE_INIT, (_T("### ATA-Disk dose not support UDMA. It is running on PDMA\r\n")));
}
else {
SetPioMode(m_Id.AdvancedPIOxferreserved);
m_pPort->m_pDskReg[m_dwDeviceId]->dwEnableUDMA = FALSE;;
m_pPort->m_pDskReg[m_dwDeviceId]->dwEnablePDMA = FALSE;;
DEBUGMSG(ZONE_INIT, (_T("### ATA-Disk is running on PIO MODE\r\n")));
DEBUGMSG(ZONE_INIT, (_T("Atapi!CDisk::Init> Disabled DMA\r\n")));
}
// associate interrupt event with IRQ
if (!InterruptInitialize(
m_pPort->m_dwSysIntr,
m_pPort->m_hIRQEvent,
NULL,
0)
) {
DEBUGMSG(ZONE_INIT|ZONE_ERROR, (_T(
"Atapi!CRomiDisk::ConfigPort> Failed to initialize interrupt(SysIntr(%d)) for device(%d)\r\n"
), m_pPort->m_dwSysIntr, m_dwDeviceId));
bRet = FALSE;
}
if (!bRet) {
goto exit;
}
exit:;
return bRet;
}
// New Start function for Card detect of HSMMC ch1 on SMDK6410.
SD_API_STATUS CSDHControllerCh1::Start() {
SD_API_STATUS status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
m_fDriverShutdown = FALSE;
// allocate the interrupt event
m_hevInterrupt = CreateEvent(NULL, FALSE, FALSE,NULL);
if (NULL == m_hevInterrupt) {
goto EXIT;
}
// initialize the interrupt event
if (!InterruptInitialize (m_dwSysIntr, m_hevInterrupt, NULL, 0)) {
goto EXIT;
}
m_fInterruptInitialized = TRUE;
// create the interrupt thread for controller interrupts
m_htIST = CreateThread(NULL, 0, ISTStub, this, 0, NULL);
if (NULL == m_htIST) {
goto EXIT;
}
// allocate the card detect event
m_hevCardDetectEvent = CreateEvent(NULL, FALSE, FALSE,NULL);
if (NULL == m_hevCardDetectEvent) {
goto EXIT;
}
// initialize the interrupt event
if (!InterruptInitialize (m_dwSDDetectSysIntr, m_hevCardDetectEvent, NULL, 0)) {
goto EXIT;
}
// create the card detect interrupt thread
m_htCardDetectThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SD_CardDetectThread, this, 0, NULL);
if (NULL == m_htCardDetectThread) {
goto EXIT;
}
for (DWORD dwSlot = 0; dwSlot < m_cSlots; ++dwSlot) {
PCSDHCSlotBase pSlot = GetSlot(dwSlot);
status = pSlot->Start();
if (!SD_API_SUCCESS(status)) {
goto EXIT;
}
}
// wake up the interrupt thread to check the slot
::SetInterruptEvent(m_dwSDDetectSysIntr);
status = SD_API_STATUS_SUCCESS;
EXIT:
if (!SD_API_SUCCESS(status)) {
// Clean up
Stop();
}
return status;
}
EXTERN_C DWORD FSC_Init(void *pContext)
{
DWORD irqs[4], size;
//clear register
//fgClearGroup(); // It clear all share registers including ARM2 AEC. Don't do that( mtk40004)
g_hBackCar = OpenEvent(EVENT_ALL_ACCESS,FALSE,BACKCAR_EVENT_NAME);
if(g_hBackCar == NULL)
{
g_hBackCar = CreateEvent(0, FALSE, FALSE, BACKCAR_EVENT_NAME);
}
// Prepare irq list
irqs[0] = -1;
irqs[1] = 0;
irqs[2] = VECTOR_INT_DUAL2;
size = 3 * sizeof(DWORD);
// request sysIntr
if (!KernelIoControl(
IOCTL_HAL_REQUEST_SYSINTR, irqs, size,
&g_dwBackCarSysIntr, sizeof(g_dwBackCarSysIntr), NULL
))
{
RETAILMSG(ZONE_ERROR, (TEXT("FSC_Init() IOCTL_HAL_REQUEST_SYSTINR call failed\r\n")));
return FALSE;
}
RETAILMSG(ZONE_ERROR, (TEXT("FSC_Init() g_dwBackCarSysIntr = %d !\r\n"), g_dwBackCarSysIntr));
// Create interrupt event
g_hBackCarIntrEvt = CreateEvent(0, FALSE, FALSE, NULL);
if ( g_hBackCarIntrEvt == NULL )
{
DEBUGMSG(ZONE_ERROR, (TEXT("FSC_Init() Error creating interrupt event\r\n")));
return FALSE;
}
// Initialize interrupt
if (!InterruptInitialize(g_dwBackCarSysIntr, g_hBackCarIntrEvt, NULL, 0))
{
RETAILMSG(ZONE_ERROR, (TEXT("FSC_Init() Interrupt initialization failed\r\n")));
return FALSE;
}
// create the sleep control IST thread
g_hBackIntrThread = CreateThread(NULL, 0, BackCarIST, NULL, 0, NULL);
if (g_hBackIntrThread == NULL) {
InterruptDisable(g_dwBackCarSysIntr);
if (g_hBackCarIntrEvt) {
CloseHandle(g_hBackCarIntrEvt);
g_hBackCarIntrEvt = NULL;
}
RETAILMSG(ZONE_ERROR, (TEXT("FSC_Init() failed for creating sleep control IST thread\r\n")));
return FALSE;
}
g_ARM2CommEnvt = CreateEvent(NULL,FALSE, FALSE, NULL);
if(NULL == g_ARM2CommEnvt)
{
RETAILMSG(TRUE, (TEXT("CreateEvent ARM2 COMM Event Failed\r\n")));
return FALSE;
}
//Create WINCE Ready detect Thread
CreateThread(NULL, 0, DetectFSCUIReadyThread, NULL, 0, NULL);
return ((DWORD)1);
} /* FSC_Init() */
DWORD
HW_Init(
PI2C_CONTEXT pI2C
)
{
DWORD dwErr = ERROR_SUCCESS;
UINT32 Irq;
// RETAILMSG(1,(TEXT("I2C Init\r\n")));
if ( !pI2C ) {
return ERROR_INVALID_PARAMETER;
}
DEBUGMSG(ZONE_TRACE,(TEXT("+I2C_Init: %u, 0x%x, 0x%x \r\n"),
pI2C->Mode, pI2C->SlaveAddress));
InitializeCriticalSection(&pI2C->RegCS);
pI2C->Status = 0;
pI2C->Data = NULL;
pI2C->DataCount = INVALID_DATA_COUNT;
pI2C->Flags.DropRxAddr = FALSE;
pI2C->hProc = (HANDLE)GetCurrentProcessId();
InitRegs(pI2C);
// create I/O Done Event
if ( (pI2C->DoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL)
{
dwErr = GetLastError();
DEBUGMSG(ZONE_ERR,(TEXT("I2C_Init ERROR: Unable to create Done event: %u \r\n"), dwErr));
goto _init_error;
}
// setup Operating Mode
if ( pI2C->Mode == INTERRUPT ) {
// create IST event
if ( (pI2C->ISTEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL)
{
dwErr = GetLastError();
DEBUGMSG(ZONE_ERR,(TEXT("I2C_Init ERROR: Unable to create IST event: %u \r\n"), dwErr));
goto _init_error;
}
// Obtain sysintr values from the OAL for the camera interrupt.
//
Irq = IRQ_I2C;
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &Irq, sizeof(UINT32), &gIntrIIC, sizeof(UINT32), NULL))
{
DEBUGMSG(ZONE_ERR, (TEXT("ERROR: Failed to request the IIC sysintr.\r\n")));
gIntrIIC = SYSINTR_UNDEFINED;
return(FALSE);
}
// RETAILMSG(1, (TEXT("IIC IRQ mapping: [IRQ:%d->sysIRQ:%d].\r\n"), Irq, gIntrIIC));
// initialize the interrupt
if( !InterruptInitialize(gIntrIIC, pI2C->ISTEvent, NULL, 0) )
{
dwErr = GetLastError();
DEBUGMSG(ZONE_ERR,(TEXT("I2C_Init ERROR: Unable to initialize interrupt: %u\r\n"), dwErr));
goto _init_error;
}
InterruptDone(gIntrIIC);
// create the IST
if ( (pI2C->IST = CreateThread(NULL, 0, I2C_IST, (LPVOID)pI2C, 0, NULL)) == NULL)
{
dwErr = GetLastError();
DEBUGMSG(ZONE_ERR,(TEXT("I2C_Init ERROR: Unable to create IST: %u\r\n"), dwErr));
goto _init_error;
}
// TODO: registry override
if ( !CeSetThreadPriority(pI2C->IST, I2C_THREAD_PRIORITY)) {
dwErr = GetLastError();
DEBUGMSG(ZONE_ERR, (TEXT("I2C_Init ERROR: CeSetThreadPriority ERROR:%d\n"), dwErr));
goto _init_error;
}
}
DEBUGMSG(ZONE_TRACE,(TEXT("-I2C_Init \r\n")));
return dwErr;
_init_error:
HW_Deinit(pI2C);
return dwErr;
}
static BOOL
PWR_AllocResources(void)
{
DWORD dwIRQ;
PWRBTN_MSG((_T("[PWR] ++PWR_AllocResources()\r\n")));
//------------------
// GPIO Controller SFR
//------------------
g_pGPIOReg = (S3C6410_GPIO_REG *)DrvLib_MapIoSpace(S3C6410_BASE_REG_PA_GPIO, sizeof(S3C6410_GPIO_REG), FALSE);
if (g_pGPIOReg == NULL)
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : pGPIOReg DrvLib_MapIoSpace() Failed \n\r")));
return FALSE;
}
//--------------------
// Power Button Interrupt
//--------------------
dwIRQ = IRQ_EINT11;
g_dwSysIntrPowerBtn = SYSINTR_UNDEFINED;
g_hEventPowerBtn = NULL;
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &g_dwSysIntrPowerBtn, sizeof(DWORD), NULL))
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : IOCTL_HAL_REQUEST_SYSINTR Power Button Failed \n\r")));
g_dwSysIntrPowerBtn = SYSINTR_UNDEFINED;
return FALSE;
}
g_hEventPowerBtn = CreateEvent(NULL, FALSE, FALSE, NULL);
if(NULL == g_hEventPowerBtn)
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : CreateEvent() Power Button Failed \n\r")));
return FALSE;
}
if (!(InterruptInitialize(g_dwSysIntrPowerBtn, g_hEventPowerBtn, 0, 0)))
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : InterruptInitialize() Power Button Failed \n\r")));
return FALSE;
}
//--------------------
// Reset Button Interrupt
//--------------------
/*dwIRQ = IRQ_EINT9;
g_dwSysIntrResetBtn = SYSINTR_UNDEFINED;
g_hEventResetBtn = NULL;
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &g_dwSysIntrResetBtn, sizeof(DWORD), NULL))
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : IOCTL_HAL_REQUEST_SYSINTR Reset Button Failed \n\r")));
g_dwSysIntrResetBtn = SYSINTR_UNDEFINED;
return FALSE;
}
g_hEventResetBtn = CreateEvent(NULL, FALSE, FALSE, NULL);
if(NULL == g_hEventResetBtn)
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : CreateEvent() Reset Button Failed \n\r")));
return FALSE;
}
if (!(InterruptInitialize(g_dwSysIntrResetBtn, g_hEventResetBtn, 0, 0)))
{
PWRBTN_ERR((_T("[PWR:ERR] PWR_AllocResources() : InterruptInitialize() Reset Button Failed \n\r")));
return FALSE;
}
*/
PWRBTN_MSG((_T("[PWR] --PWR_AllocResources()\r\n")));
return TRUE;
}
/*----------------------------------------------------------------------------*/
NDIS_STATUS
windowsRegisterIsrt (
IN P_GLUE_INFO_T prGlueInfo
)
{
NDIS_STATUS rStatus;
P_GL_HIF_INFO_T prHifInfo;
DEBUGFUNC("windowsRegisterIsrt");
ASSERT(prGlueInfo);
prHifInfo = &prGlueInfo->rHifInfo;
/* Next we'll register our interrupt with the NDIS wrapper. */
/* Hook our interrupt vector. We used level-triggered, shared
interrupts with our PCI adapters. */
INITLOG(("Register IRQ: handle=0x%x, irq=0x%x, level-triggered\n",
prGlueInfo->rMiniportAdapterHandle, prHifInfo->u4InterruptLevel));
rStatus = NdisMRegisterInterrupt(&prHifInfo->rInterrupt,
prGlueInfo->rMiniportAdapterHandle,
(UINT) prHifInfo->u4InterruptVector,
(UINT) prHifInfo->u4InterruptLevel,
TRUE, /* RequestIsr */
FALSE, /* SharedInterrupt */
NIC_INTERRUPT_MODE);
if (rStatus != NDIS_STATUS_SUCCESS) {
ERRORLOG(("Interrupt conflict: status=0x%08x, IRQ=%d, level-sensitive\n",
rStatus, prHifInfo->u4InterruptLevel));
NdisWriteErrorLogEntry(prGlueInfo->rMiniportAdapterHandle,
NDIS_ERROR_CODE_INTERRUPT_CONNECT, 1,
(UINT_32) prHifInfo->u4InterruptLevel);
}
GLUE_SET_FLAG(prGlueInfo, GLUE_FLAG_INTERRUPT_IN_USE);
INITLOG(("Register interrupt -- OK\n"));
#if SC32442_SPI
{
UINT_32 g_SysIntr;
prHifInfo->gWaitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR,
&prHifInfo->u4InterruptLevel,
sizeof(UINT32), &g_SysIntr,
sizeof(UINT32), NULL)) {
INITLOG(("ERROR:Failed to request sysintr value for Timer1 inturrupt!/n"));
}
else {
INITLOG(("Request sysintr value %d!/r/n", g_SysIntr));
prHifInfo->u4sysIntr = g_SysIntr;
}
if (!(InterruptInitialize(g_SysIntr, prHifInfo->gWaitEvent, 0, 0)))
{
INITLOG(("ERROR: Interrupt initialize failed.\n"));
}
}
#endif
return rStatus;
} /* windowsRegisterIsrt */
PSPI_PUBLIC_CONTEXT HSP_Init(PVOID Context)
{
LPTSTR ActivePath = (LPTSTR) Context; // HKLM\Drivers\Active\xx
PSPI_PUBLIC_CONTEXT pPublicSpi = NULL;
BOOL bResult = TRUE;
DWORD dwHwIntr=0;
RETAILMSG(1,(TEXT("++HSP_Init Function\r\n")));
RETAILMSG(1,(TEXT("Active Path : %s\n"), ActivePath));
if ( !(pPublicSpi = (PSPI_PUBLIC_CONTEXT)LocalAlloc( LPTR, sizeof(SPI_PUBLIC_CONTEXT) )) )
{
RETAILMSG(1,(TEXT("Can't not allocate for SPI Context\n")));
return NULL;
}
if(!HW_Init(pPublicSpi))
{
RETAILMSG(1,(TEXT("HW_Init is failed\n")));
return NULL;
} else {
RETAILMSG(1,(TEXT("HW_Init is completed\n")));
}
do
{
InitializeCriticalSection(&(pPublicSpi->CsRxAccess));
InitializeCriticalSection(&(pPublicSpi->CsTxAccess));
//Rx Thread
pPublicSpi->hRxEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pPublicSpi->hRxThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ThreadForRx, (LPVOID)pPublicSpi, 0, (LPDWORD)&pPublicSpi->dwRxThreadId);
if (pPublicSpi->hRxThread == NULL)
{
RETAILMSG(1,(TEXT("SPI Rx Thread creation error!!!\n")));
bResult = FALSE;
break;
}
pPublicSpi->hRxDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pPublicSpi->hRxIntrDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
//Tx Thread
pPublicSpi->hTxEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pPublicSpi->hTxThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ThreadForTx, (LPVOID)pPublicSpi, 0, (LPDWORD)&pPublicSpi->dwTxThreadId);
if (pPublicSpi->hTxThread == NULL)
{
RETAILMSG(1,(TEXT("SPI Dma Thread creation error!!!\n")));
bResult = FALSE;
break;
}
pPublicSpi->hTxDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pPublicSpi->hTxIntrDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
//Spi ISR
pPublicSpi->dwSpiSysIntr = SYSINTR_NOP;
dwHwIntr = IRQ_SPI1; //HS-SPI
pPublicSpi->hSpiEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwHwIntr, sizeof(DWORD), &pPublicSpi->dwSpiSysIntr, sizeof(DWORD), NULL))
{
RETAILMSG(1,(TEXT("Failed to request the SPI sysintr.\n")));
pPublicSpi->dwSpiSysIntr = SYSINTR_UNDEFINED;
bResult = FALSE;
break;
}
if (!InterruptInitialize(pPublicSpi->dwSpiSysIntr, pPublicSpi->hSpiEvent, NULL, 0))
{
RETAILMSG(1,(TEXT("SPI Interrupt Initialization failed!!!\n")));
bResult = FALSE;
break;
}
pPublicSpi->hSpiThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ThreadForSpi, (LPVOID)pPublicSpi, 0, (LPDWORD)&pPublicSpi->dwSpiThreadId);
if (pPublicSpi->hSpiThread == NULL)
{
RETAILMSG(1,(TEXT("SPI ISR Thread creation error!!!\n")));
bResult = FALSE;
break;
}
//Rx DMA Done ISR
pPublicSpi->dwRxDmaDoneSysIntr = SYSINTR_NOP;
dwHwIntr = IRQ_DMA3;
pPublicSpi->hRxDmaDoneDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pPublicSpi->hRxDmaDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwHwIntr, sizeof(DWORD), &pPublicSpi->dwRxDmaDoneSysIntr, sizeof(DWORD), NULL))
{
RETAILMSG(1,(TEXT("Failed to request the SPI_DMA sysintr.\n")));
pPublicSpi->dwRxDmaDoneSysIntr = SYSINTR_UNDEFINED;
bResult = FALSE;
break;
}
if (!InterruptInitialize(pPublicSpi->dwRxDmaDoneSysIntr, pPublicSpi->hRxDmaDoneEvent, NULL, 0))
{
RETAILMSG(1,(TEXT("DMA Interrupt Initialization failed!!!\n")));
bResult = FALSE;
break;
}
pPublicSpi->hRxDmaDoneThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ThreadForRxDmaDone, (LPVOID)pPublicSpi, 0, (LPDWORD)&pPublicSpi->dwRxDmaDoneThreadId);
if (pPublicSpi->hRxDmaDoneThread == NULL)
{
RETAILMSG(1,(TEXT("SPI Dma Thread creation error!!!\n")));
bResult = FALSE;
break;
}
//Tx DMA Done ISR
pPublicSpi->dwTxDmaDoneSysIntr = SYSINTR_NOP;
dwHwIntr = IRQ_DMA4;
pPublicSpi->hTxDmaDoneDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pPublicSpi->hTxDmaDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwHwIntr, sizeof(DWORD), &pPublicSpi->dwTxDmaDoneSysIntr, sizeof(DWORD), NULL))
{
RETAILMSG(1,(TEXT("Failed to request the SPI_DMA sysintr.\n")));
pPublicSpi->dwTxDmaDoneSysIntr = SYSINTR_UNDEFINED;
bResult = FALSE;
break;
}
if (!InterruptInitialize(pPublicSpi->dwTxDmaDoneSysIntr, pPublicSpi->hTxDmaDoneEvent, NULL, 0))
{
RETAILMSG(1,(TEXT("DMA Interrupt Initialization failed!!!\n")));
bResult = FALSE;
break;
}
pPublicSpi->hTxDmaDoneThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ThreadForTxDmaDone, (LPVOID)pPublicSpi, 0, (LPDWORD)&pPublicSpi->dwTxDmaDoneThreadId);
if (pPublicSpi->hTxDmaDoneThread == NULL)
{
RETAILMSG(1,(TEXT("SPI Dma Thread creation error!!!\n")));
bResult = FALSE;
break;
}
} while (0);
if(bResult) return pPublicSpi;
else return NULL;
}
