hciusb.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.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:  

    hciusb.cpp

Abstract:  

    Bluetooth HCI USB interface

    
Functions:


Notes:

--*/

#include <windows.h>
#include <windev.h>
#include <usbdi.h>

#include <bt_buffer.h>
#include <bt_hcip.h>
#include <bt_os.h>
#include <bt_debug.h>
#include <svsutil.hxx>

#include <bt_tdbg.h>

#include "usbdev.h"

HCI_TransportCallback gCallback = NULL;

int HCI_ReadHciParameters (HCI_PARAMETERS *pParms)
{
	if (pParms->uiSize < sizeof (*pParms))
		return FALSE;

	memset (pParms, 0, sizeof(*pParms));

	pParms->uiSize                  = sizeof(*pParms);
	pParms->fInterfaceVersion       = HCI_INTERFACE_VERSION_1_1;
	pParms->iMaxSizeRead            = PACKET_SIZE_R;
	pParms->iMaxSizeWrite           = PACKET_SIZE_W;
	pParms->iWriteBufferHeader      = 0;
	pParms->iWriteBufferTrailer     = 0;
	pParms->fHardwareVersion        = HCI_HARDWARE_VERSION_V_1_0_B;
	pParms->uiWriteTimeout          = HCI_DEFAULT_WRITE_TIMEOUT;
	pParms->uiDriftFactor           = HCI_DEFAULT_DRIFT;
	pParms->uiFlags                 = 0;

	pParms->iScoWriteLowNumPackets  = SCO_DEFAULT_WRITE_LOW_NUM_PACKETS;
	pParms->iScoWriteNumPackets     = SCO_DEFAULT_WRITE_HIGH_NUM_PACKETS;
	pParms->iScoWritePacketSize     = SCO_DEFAULT_PACKET_SIZE;
	pParms->iScoSampleSize			= SCO_DEFAULT_SAMPLE_SIZE;

	HKEY hk;

	if (RegOpenKeyEx (HKEY_BASE, L"Software\\Microsoft\\Bluetooth\\hci", 0, KEY_READ, &hk) == ERROR_SUCCESS) { 
		DWORD dwType = 0;
		DWORD dwData = 0;
		DWORD dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"SpecV10a", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->fHardwareVersion = HCI_HARDWARE_VERSION_V_1_0_A;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"SpecV11", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->fHardwareVersion = HCI_HARDWARE_VERSION_V_1_1;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"Flags", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->uiFlags = dwData;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"Drift", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->uiDriftFactor = dwData;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"ScoWriteLowNumPackets", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->iScoWriteLowNumPackets = dwData;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"ScoWriteNumPackets", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->iScoWriteNumPackets = dwData;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"ScoWritePacketSize", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->iScoWritePacketSize = dwData;

		dwData = 0;
		dwSize = sizeof(dwData);
		if ((RegQueryValueEx (hk, L"ScoSampleSize", NULL, &dwType, (LPBYTE)&dwData, &dwSize) == ERROR_SUCCESS) &&
			(dwType == REG_DWORD) && (dwSize == sizeof(dwData)) && dwData)
			pParms->iScoSampleSize = dwData;

		RegCloseKey (hk);
	}

	return TRUE;

}

int HCI_StartHardware (void) 
{
	IFDBG(DebugOut (DEBUG_HCI_INIT, L"+HCI_StartHardware\n"));

	if (!gpUsbDevice->StartHardware()) 
	{
		IFDBG(DebugOut (DEBUG_HCI_INIT, L"-HCI_StartHardware (No USB device detected)\n"));
		return FALSE;
	}

	if (! gCallback) 
	{
		IFDBG(DebugOut (DEBUG_HCI_INIT, L"-HCI_StartHardware (not registered)\n"));
		return FALSE;
	}

	return ERROR_SUCCESS == gCallback (DEVICE_UP, NULL);
}

int HCI_StopHardware (void) 
{
	IFDBG(DebugOut (DEBUG_HCI_INIT, L"+HCI_StopHardware\n"));
	
	gpUsbDevice->StopHardware();

	if (! gCallback) 
	{
		IFDBG(DebugOut (DEBUG_HCI_INIT, L"-HCI_StartHardware (not registered)\n"));
		return FALSE;
	}

	return ERROR_SUCCESS == gCallback (DEVICE_DOWN, NULL);
}

int HCI_SetCallback (HCI_TransportCallback pfCallback) 
{
	gpsynchUsbDevice->Lock();

	gCallback = pfCallback;

	if (gCallback)
		DebugInit();
	else
		DebugDeInit();

	gpsynchUsbDevice->Unlock();

	return ERROR_SUCCESS;
}

int HCI_OpenConnection (void) 
{
	IFDBG(DebugOut (DEBUG_HCI_INIT, L"HCI_OpenConnection - Started\n"));

	if (ERROR_SUCCESS == gpUsbDevice->OpenConnection())
	{
		IFDBG(DebugOut (DEBUG_HCI_INIT, L"HCI_OpenConnection - Successful\n"));
		return TRUE;
	}
	else
	{
		IFDBG(DebugOut (DEBUG_HCI_INIT, L"HCI_OpenConnection - Failed...\n"));
		return FALSE;
	}
}

void HCI_CloseConnection (void) 
{
	IFDBG(DebugOut (DEBUG_HCI_INIT, L"HCI_CloseConnection - Started\n"));

	if (!gpUsbDevice)
	{
		IFDBG(DebugOut (DEBUG_ERROR, L"HCI_CloseConnection - device not active\n"));
		return;
	}

	gpUsbDevice->CloseConnection();

	IFDBG(DebugOut (DEBUG_HCI_INIT, L"HCI_CloseConnection - Completed\n"));
}

int HCI_WritePacket (HCI_TYPE eType, BD_BUFFER *pBuff)
{
	int iUserSize = BufferTotal (pBuff);

	IFDBG(DebugOut (DEBUG_HCI_TRANSPORT, L"HCI_WritePacket type 0x%02x len %d\n", eType, iUserSize));

	if (iUserSize > PACKET_SIZE_W) 
	{
		IFDBG(DebugOut (DEBUG_ERROR, L"[UART] Packet too big (%d, should be <= %d), or no space for header!\n", BufferTotal (pBuff), PACKET_SIZE_W));
		return FALSE;
	}

#if defined (DEBUG) || defined (_DEBUG)
	DumpBuff (DEBUG_HCI_DUMP, pBuff->pBuffer, BufferTotal(pBuff));
#endif

	if (!gpUsbDevice->WritePacket(&pBuff->pBuffer[pBuff->cStart], BufferTotal(pBuff), eType))
		return FALSE;

	IFDBG(DebugOut (DEBUG_HCI_TRANSPORT, L"HCI_WritePacket : DONE type 0x%02x len %d\n", eType, BufferTotal (pBuff)));
	return TRUE;

}

int HCI_ReadPacket (HCI_TYPE *peType, BD_BUFFER *pBuff)
{
	IFDBG(DebugOut (DEBUG_HCI_TRANSPORT, L"HCI_ReadPacket\n"));
	
	int iUserSize = BufferTotal(pBuff);

	if (iUserSize < PACKET_SIZE_R)
	{
		IFDBG(DebugOut (DEBUG_ERROR, L"[UART] Packet too big (%d, should be <= %d), or no space for header!\n", BufferTotal (pBuff), PACKET_SIZE_W));
		return FALSE;
	}

	int nSize, nType;
	if (!gpUsbDevice->ReadPacket(&pBuff->pBuffer[pBuff->cStart], &nSize, &nType))
	{
		IFDBG(DebugOut(DEBUG_ERROR, L"HCIUSB : ReadPacket failed.\n"));
		return FALSE;
	}

	ASSERT(nSize < PACKET_SIZE_R);

	pBuff->cEnd = pBuff->cStart + nSize;

	switch(nType)
	{
		case EVENT_BULK:			// ACL packet
			*peType = DATA_PACKET_ACL;

			IFDBG(DebugOut (DEBUG_HCI_DUMP, L"HCI_ReadPacket: ACL\n"));
			IFDBG(DumpBuff (DEBUG_HCI_DUMP, pBuff->pBuffer, nSize));
			return TRUE;

		case EVENT_INTERRUPT:			// HCI Event
			*peType = EVENT_PACKET;

			IFDBG(DebugOut (DEBUG_HCI_DUMP, L"HCI_ReadPacket: Event\n"));
			IFDBG(DumpBuff (DEBUG_HCI_DUMP, pBuff->pBuffer, nSize));
			return TRUE;

		case EVENT_ISOCH:			// SCO packet
			*peType = DATA_PACKET_SCO;

			IFDBG(DebugOut (DEBUG_HCI_DUMP, L"HCI_ReadPacket: SCO\n"));
			IFDBG(DumpBuff (DEBUG_HCI_DUMP, pBuff->pBuffer, nSize));
			return TRUE;

		default: 
			IFDBG(DebugOut (DEBUG_HCI_DUMP, L"Unknown packet (ignoring)\n"));
			IFDBG(DumpBuff (DEBUG_HCI_DUMP, pBuff->pBuffer, nSize));
			ASSERT(FALSE);
			break;
	}

	return FALSE;
}