btdriverstreaminit.cpp

Windows CE操作系统中适用的蓝牙驱动程序

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
#include "BTDriverStream.h"

#define CONFIG_BASE_ADDRESS 0x300
#define BT_REG_LENGTH	64

DWORD gCONFIG_BASE_ADDRESS = CONFIG_BASE_ADDRESS;

REGISTERCLIENT      v_pfnCardRegisterClient;
DEREGISTERCLIENT    v_pfnCardDeregisterClient;
GETFIRSTTUPLE       v_pfnCardGetFirstTuple;
GETNEXTTUPLE        v_pfnCardGetNextTuple;
GETTUPLEDATA        v_pfnCardGetTupleData;
GETPARSEDTUPLE      v_pfnCardGetParsedTuple;
REQUESTWINDOW       v_pfnCardRequestWindow;
RELEASEWINDOW       v_pfnCardReleaseWindow;
MAPWINDOW           v_pfnCardMapWindow;
REQUESTCONFIG       v_pfnCardRequestConfiguration;
RELEASECONFIG       v_pfnCardReleaseConfiguration;
REQUESTIRQ          v_pfnCardRequestIRQ;
RELEASEIRQ          v_pfnCardReleaseIRQ;
GETSTATUS           v_pfnCardGetStatus;

//
// Returns TRUE if there is a card inserted in the specified socket
//
static BOOL
IsCardInserted(
    CARD_SOCKET_HANDLE hSock
    )
{
    DEBUGMSG(ZONE_INIT, (L"WceStreamBT: IsCardInserted\r\n"));

	STATUS status;
    CARD_STATUS CardStatus;

    CardStatus.hSocket = hSock;
    status = v_pfnCardGetStatus(&CardStatus);
    if (status == CERR_SUCCESS) 
	{
        if (CardStatus.fCardState & EVENT_MASK_CARD_DETECT) 
		{
            return TRUE;
        }
    } 
	else 
	{
		DEBUGMSG(ZONE_INIT, (L"CardGetStatus returned 0x%x\r\n", status));
    }

    return FALSE;
}   // IsCardInserted



//////////////////////////////////////////////////////////////////
// CreateBTObject: Corresponds to initializing the device extension 
// for a kernel mode driver.
// Set all default values
// Allocate memory for buffers etc
// Initialize critical sections, timers, DPC etc etc
///////////////////////////////////////////////////////////////////
static PWSSBTCLIENT_CONTEXT
CreateBTObject()
{
	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: CreateBTObject\r\n"));

	PWSSBTCLIENT_CONTEXT pbtcc = (PWSSBTCLIENT_CONTEXT) LocalAlloc(LPTR, sizeof(WSSBTCLIENT_CONTEXT));
	if (! pbtcc)
		return NULL;

	pbtcc->ioBase = (BYTE *)NULL;
	pbtcc->identifier = OURIDENTIFIER;

	pbtcc->hSocket.uFunction = 0xFF;
	pbtcc->hSocket.uSocket = 0xFF;
	
	pbtcc->sendBuffer = NULL;
	pbtcc->receiveBuffer = NULL;

	pbtcc->sendBuffer = new DataBuffer(DEFAULT_TX_BUFFER_SIZE);
	if(!pbtcc->sendBuffer)
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Insufficient resources for send buffer\r\n"));
		LocalFree(pbtcc);
		return NULL;
	}

	pbtcc->receiveBuffer = new DataBuffer(INITIALRECEIVEBUFFERSIZE);
	if(!pbtcc->receiveBuffer)
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Insufficient resources for receive buffer\r\n"));
		LocalFree(pbtcc);
		return NULL;
	}

	pbtcc->fDriverStarted = FALSE;

	pbtcc->hWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (pbtcc->hWriteEvent == NULL) 
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Could not create write event\r\n"));
        LocalFree(pbtcc);
		return NULL;
    }

	pbtcc->hReadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (pbtcc->hReadEvent == NULL) 
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Could not create read event\r\n"));
        LocalFree(pbtcc);
		return NULL;
    }

    pbtcc->CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF ;
    pbtcc->CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
    pbtcc->CommTimeOuts.ReadTotalTimeoutConstant = 1000 ;
    pbtcc->CommTimeOuts.WriteTotalTimeoutMultiplier = 0 ;
    pbtcc->CommTimeOuts.WriteTotalTimeoutConstant = 1000 ;

    return pbtcc;
}

/////////////////////////////////////////////////////////////////
// CloseBTObject: Undo what was done in CreateBTObject,
// and tell PCMCIA controller to deregister us as client
////////////////////////////////////////////////////////////////
static void
CloseBTObject(PWSSBTCLIENT_CONTEXT pbtcc)
{
	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: CloseBTObject\r\n"));

	if (! pbtcc)
		return;

	SetEvent(pbtcc->hWriteEvent);
	CloseHandle(pbtcc->hWriteEvent);

	SetEvent(pbtcc->hReadEvent);
	CloseHandle(pbtcc->hReadEvent);

	if (pbtcc->hCardClient)
	{
		STATUS status = v_pfnCardReleaseConfiguration(pbtcc->hCardClient, pbtcc->hSocket);

		if (status != CERR_SUCCESS) 
		{
			DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: CardReleaseConfiguration failed 0x%x\r\n", status));
		}

		status = CERR_BAD_HANDLE;
		status = v_pfnCardDeregisterClient(pbtcc->hCardClient);
		if (status != CERR_SUCCESS) 
		{
			DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: CardDeregisterClient failed 0x%x\r\n", status));
		}
	}

	if(pbtcc->sendBuffer)
	{
		delete pbtcc->sendBuffer;
	}

	if(pbtcc->receiveBuffer)
	{
		delete pbtcc->receiveBuffer;
	}
	
	LocalFree(pbtcc);
}

static STATUS
BTWSSInitCard(PWSSBTCLIENT_CONTEXT ptrcc)
{
	DEBUGMSG(ZONE_TRACE, (L"WceStreamBT: BTWSSInitCard\r\n"));

	STATUS				status = CERR_SUCCESS;
		
	//Check if our PCCARD is ok

	BYTE id = 0;

	__try
	{
		id = READ_PORT_UCHAR(ptrcc->ioBase + CARD_RESET_OFFSET);
	} __except (1)
	{
		id = 0;
	}

	if((id & PCCARD_ID_MASK) != PCCARD_IDENTIFIER)
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: BTWSSInitCard: Failed to identify our pc-card: 0x%x",id));
		return CERR_BAD_ADAPTER;
	}

	BTWSSResetCard(ptrcc);
	return status;
}

//------------------------------------------------------------------------------

static STATUS StatusCallback(CARD_EVENT EventCode, CARD_SOCKET_HANDLE hSocket,
	PCARD_EVENT_PARMS pParms)
{
	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: StatusCallback, code 0x%08x\r\n", EventCode));

	PWSSBTCLIENT_CONTEXT pcc = (PWSSBTCLIENT_CONTEXT)pParms->uClientData;

	switch (EventCode) 
	{
    case CE_EXCLUSIVE_REQUEST:
		if (pcc != NULL) 
		{
            return CERR_IN_USE;    
        }
		break;			

    case CE_CARD_REMOVAL:
        
        // If this is not an artificial removal notice, then indicate that in the
        // card's global state.
		if (pcc != NULL) 
		{
            if (IsCardInserted(pcc->hSocket) == FALSE) 
			{
				DEBUGMSG(ZONE_WARN, (L"WceStreamBT: card removed\r\n"));
            }
        }
        break;
    }

	return CERR_SUCCESS;
} 

//------------------------------------------------------------------------------

static BOOL getSocketHandle(LPTSTR activePath, PCARD_SOCKET_HANDLE phSocket)
{ 
	HKEY hKey;
	DWORD valType, valLen;

	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: getSocketHandle\r\n"));

	// Open the active device key (return error if it fails).
	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, activePath, 0, 0, &hKey))
	{
		DEBUGMSG(ZONE_WARN, (L"WceStreamBT: getSocketHandle FAILED (no key)\r\n"));
		return FALSE;
	}
	
	// Read the socket handle from the key (return error if it fails).
	valLen = sizeof(CARD_SOCKET_HANDLE);
	if (RegQueryValueEx(hKey, DEVLOAD_SOCKET_VALNAME, 0, 
			&valType, (LPBYTE)phSocket, &valLen)) 
	{
		RegCloseKey(hKey); 

		DEBUGMSG(ZONE_WARN, (L"WceStreamBT: getSocketHandle FAILED (no handle)\r\n"));
		return FALSE;
	}

	RegCloseKey(hKey); 

	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: %s %d Socket: %d Function : %d", activePath, phSocket, phSocket->uSocket, phSocket->uFunction));

	return TRUE;
} 

///////////////////////////////////////////////////////////////
// WBT_Init: Called when our driver is loaded
// Allocate the device extension and initialize what needs to be initialized
// Also register as CardClient with CardServices
////////////////////////////////////////////////////////////////

DWORD WBT_Init(DWORD dwContext)
{
	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: WBT_Init\r\n"));

	PWSSBTCLIENT_CONTEXT	pcc = 0;

	if (g_pCC) {
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Context already created\r\n"));
		goto errret;
	}

	BOOL InitPcmciaDll(VOID);
	if (! InitPcmciaDll ())
		goto errret;

	CARD_REGISTER_PARMS		parms;

	// Allocate client context structure (cleared to zeros).
	pcc = CreateBTObject();
	if(!pcc) 
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Failed to allocate the driver object\r\n"));
		goto errret;
	}
	
	// Get card socket handle from device registry. Note: the dwContext 
	// is a pointer to active key in registry which holds the socket handle.
	if (!getSocketHandle((LPTSTR)dwContext, &(pcc->hSocket))) 
	{
		goto errret;
	} 
		
	// Fill parms and register with card services as I/O client. 
	parms.fEventMask = EVENT_MASK_CARD_DETECT;
	parms.uClientData = (UINT32)pcc;
	parms.fAttributes = CLIENT_ATTR_IO_DRIVER | CLIENT_ATTR_NOTIFY_SHARED |
						CLIENT_ATTR_NOTIFY_EXCLUSIVE;

	pcc->hCardClient = v_pfnCardRegisterClient(StatusCallback, &parms);
	if (pcc->hCardClient == 0) 
	{
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: CardRegisterClient failed, error=%d\r\n", GetLastError ()));
		goto errret;	 
	}

	EnterCriticalSection (&g_CS);
	if (g_pCC)
	{
		LeaveCriticalSection (&g_CS);
		DEBUGMSG(ZONE_ERROR, (L"WceStreamBT: Context already created\r\n"));
		goto errret;
	}

	g_pCC = pcc;
	LeaveCriticalSection (&g_CS);
	
	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: WBT_Init : SUCCESS\r\n"));

	return (DWORD) pcc;

	// Error return.
errret:
	CloseBTObject(pcc);

	return 0;
}



///////////////////////////////////////////////////////////
// WBT_Deinit: Called when we are unloaded (CF card is ejected)
// Deallocate memory etc and deregsiter as client with CardServices
/////////////////////////////////////////////////////////////

BOOL WBT_Deinit(DWORD dwClientContext)
{
	DEBUGMSG(ZONE_INIT, (L"WceStreamBT: WBT_Deinit\r\n"));

	for ( ; ; )
	{