hcibcsp.cpp

三星2440原版bsp

		// we now get into the processing stage so enter the critical section
		SVSLocalCriticalSection cs(&g_csBCSP);

		if (g_fShutDown)
			break;

		// now look for a new ack value to free packets from the transmit window
		if (header.ack != g_iRxAck) {
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket : received ACK = %d, scheduling ACK processing\n", header.ack));
			g_iRxAckLast = header.ack;
			SetEvent(g_hWriteThreadEvent);
		}

		// if the packet is a pure ack packet continue
		if (! header.payloadLength) {
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket : no payload, ignoring\n"));
			continue;
		}

		if (header.protocolType) { // only reliable data needs to respond to ACK
			if(header.seq == g_iTxAck) {			// this is the sequence number we were expecting
				IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket : packet in sequence, scheduling ACK send\n"));

				g_iTxAck = (g_iTxAck + 1) & BCSP_SEQ_MASK;

				if ((g_iTxUnack++) == 0)
					g_dwTxAckDue = GetTickCount () + BCSP_ACTIVE_TIMEOUT / 2;

				SetEvent(g_hWriteThreadEvent);
			} else {
				IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket : packet out of sequence, scheduling immediate ACK send\n"));

				g_iTxUnack = BCSP_SEQ_MASK + 1;
				g_dwTxAckDue = GetTickCount ();

				SetEvent(g_hWriteThreadEvent);

				continue;			// keep reading
			}
		}

		// the packet has a payload so if it is one that the client wants (ACL data or HCI event) return it
		BOOL success = TRUE;		// return this packet if true after switch

		IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got a packet.\n"));

		switch(header.protocolID) {

		case IO_DATA_PROTOCOL_NULL:
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got a null ID packet.  Discarding.\n"));
			success = FALSE;
			break;

		case IO_DATA_PROTOCOL_HCI_CMD_EVT:
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got an HCI event packet.\n"));
			*peType = EVENT_PACKET;
			break;

		case IO_DATA_PROTOCOL_HCI_ACL:
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got an ACL data packet.\n"));
			*peType = DATA_PACKET_ACL;
			break;

		case IO_DATA_PROTOCOL_HCI_SCO:
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got a SCO data packet.\n"));
			*peType = DATA_PACKET_SCO;
			break;

		case IO_DATA_PROTOCOL_CHIP_MGT_CH:
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got a chip management packet.\n"));
			success = FALSE;
			break;

		default:
			IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_ReadPacket got some unexepected packet.  Discarding.\n"));
			success = FALSE;
			break;
		}
		
		if (! success)
			continue;			// keep reading for a suitable packet

		pBuff->cEnd = header.payloadLength;
		pBuff->cStart = 0;

		IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] Packet received:\n"));
		IFDBG(DumpBuff (DEBUG_HCI_TRANSPORT, pBuff->pBuffer, pBuff->cEnd));

		return TRUE;
	}

	IFDBG(DebugOut(DEBUG_ERROR, L"[BCSP] HCI_ReadPacket failed. ERROR\n"));
	return FALSE;
}

int HCI_WritePacket (HCI_TYPE eType, BD_BUFFER *pBuff) {
	IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_WritePacket\n"));
	IFDBG(DumpBuff (DEBUG_HCI_DUMP, pBuff->pBuffer + pBuff->cStart, BufferTotal (pBuff)));

//	RETAILMSG(1, (TEXT("FUNC : HCI_WritePacket\n")));
	
	// create a packet and set the payload and header flags
	BCSPPacketListNode *pPacketListNode = new BCSPPacketListNode;
	if (! pPacketListNode) {
		IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"HCI_WritePacket: OOM!\n"));
		return FALSE;
	}

	pPacketListNode->packet.SetData(pBuff->pBuffer + pBuff->cStart, BufferTotal (pBuff));	

	if(eType == COMMAND_PACKET) 
		pPacketListNode->packet.header.protocolID = IO_DATA_PROTOCOL_HCI_CMD_EVT;
	else if(eType == DATA_PACKET_ACL)
		pPacketListNode->packet.header.protocolID = IO_DATA_PROTOCOL_HCI_ACL;
	else if(eType == DATA_PACKET_SCO)
		pPacketListNode->packet.header.protocolID = IO_DATA_PROTOCOL_HCI_SCO;

	pPacketListNode->packet.header.crcPresent = 0;
	pPacketListNode->packet.fNewPacket = TRUE;
	pPacketListNode->next = 0;

	// the remaining header fields are filled out by BCSPWriteThread prior to being sent across the wire
	if (pPacketListNode->packet.header.protocolID == IO_DATA_PROTOCOL_HCI_SCO) {
		pPacketListNode->packet.header.protocolType = 0;
		pPacketListNode->packet.header.seq = 0;
		pPacketListNode->packet.header.ack = 0;
	}
	else {
		pPacketListNode->packet.header.protocolType = 1;			// reliable connection type
	}

	// now wait for an empty slot in the transmit queue to open up
	for ( ; ; ) {
		if (g_fShutDown) {
			IFDBG(DebugOut (DEBUG_ERROR, L"[BCSP] HCI_WritePacket : shutting down!\n"));
			return FALSE;
		}

		EnterCriticalSection (&g_csBCSP);
		if (g_fShutDown) {
			IFDBG(DebugOut (DEBUG_ERROR, L"[BCSP] HCI_WritePacket : shutting down!\n"));
			LeaveCriticalSection (&g_csBCSP);

			return FALSE;
		}

		if (pPacketListNode->packet.header.protocolID == IO_DATA_PROTOCOL_HCI_SCO) {
			if (GetSCOListSize () < BCSP_WIN_SIZE_SCO)
				break;
		}
		else {
			if (GetListSize () < BCSP_WIN_SIZE)
				break;
		}

		IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_WritePacket :: waiting for empty slot...\n"));
		LeaveCriticalSection (&g_csBCSP);

		WaitForSingleObject(g_hCanTransmitPacket, INFINITE);
	}

	AddToList(pPacketListNode);

#ifdef DEBUG
	if (pPacketListNode->packet.header.protocolID == IO_DATA_PROTOCOL_HCI_SCO) {
		IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_WritePacket : SCO Packet added to the list (total %d in list)\n", GetSCOListSize()));
	}
	else {
		IFDBG(DebugOut(DEBUG_HCI_TRANSPORT, L"[BCSP] HCI_WritePacket : Packet added to the list (total %d in list)\n", GetListSize()));
	}
#endif

	SetEvent(g_hWriteThreadEvent);

	LeaveCriticalSection (&g_csBCSP);
	
	return TRUE;
}


static void InitCSRBluetooth()
{
	BCSPPacket initPacket;
	BCSPPacket sleepPacket;
	unsigned int ack, seq, sleep_ack;

	ack = 1; seq = 0; sleep_ack = 1;
	const unsigned char initPayload1[] = {0x02, 0x00, 0x14, 0x00, 0x01, 0x00, 0x03, 0x70, 0x00, 0x00,
		                                                   0x1e, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0xf1, 
		                                                   0x00, 0x1d, 0x00, 0xf5, 0x00, 0x25, 0x00, 0xf9, 0x00, 0x2b,
		                                                   0x00, 0xfd, 0x00, 0x31, 0x00, 0x00, 0x00, 0x38, 0x00, 0x03};
	//	                                                 0x19, 0x8c};

	const unsigned char initPayload2[] = {0x02, 0x00, 0x0c, 0x00, 0x02, 0x00, 0x03, 0x70, 0x00, 0x00,
								  	  0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 
								  	  0x78, 0x00, 0x02, 0x00};

	const unsigned char initPayload3[] = {0x02, 0x00, 0x09, 0x00, 0x03, 0x00, 0x03, 0x70, 0x00, 0x00,
		  							  0xf6, 0x01, 0x01, 0x00, 0x00, 0x00, 0x1d, 0x00};

	const unsigned char initPayload4[] = {0x02, 0x00, 0x09, 0x00, 0x04, 0x00, 0x03, 0x70, 0x00, 0x00,
									  0x41, 0x02, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00};

	const unsigned char initPayload5[] = {0x02, 0x00, 0x09, 0x00, 0x05, 0x00, 0x03, 0x70, 0x00, 0x00,
									  0xfe, 0x01, 0x01, 0x00, 0x00, 0x00, 0x90, 0x65};

	const unsigned char initPayload6[] = {0x02, 0x00, 0x09, 0x00, 0x06, 0x00, 0x03, 0x70, 0x00, 0x00,
									  0x40, 0x02, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00};

	const unsigned char initPayload7[] = {0x02, 0x00, 0x09, 0x00, 0x07, 0x00, 0x03, 0x70, 0x00, 0x00,
									  0x5d, 0x02, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00};

	const unsigned char initPayload8[] = {0x02, 0x00, 0x09, 0x00, 0x08, 0x00, 0x03, 0x70, 0x00, 0x00,
									  0xbe, 0x01, 0x01, 0x00, 0x00, 0x00, 0xd8, 0x01};

	const unsigned char initPayload9[] = {0x02, 0x00, 0x09, 0x00, 0x09, 0x00, 0x03, 0x70, 0x00, 0x00,
								 	  0x46, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00};

	const unsigned char warmresetPayload[] = {0x02, 0x00, 0x09, 0x00, 0x0a, 0x00, 0x02, 0x40, 0x00, 0x00,
										     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	
	initPacket.SetData(initPayload1, 40);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 40;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;

	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload2, 24);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 24;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload3, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload4, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload5, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload6, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload7, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload8, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(initPayload9, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
	ack++; seq++;
	
	sleepPacket.SetData(0, 0);
	sleepPacket.header.ack = sleep_ack;
	sleepPacket.header.seq = 0x0;
	sleepPacket.header.crcPresent = 0x0;
	sleepPacket.header.payloadLength = 0;
	sleepPacket.header.protocolID = 0x0;
	sleepPacket.header.protocolType = 0x0;
	sleepPacket.WriteToCOMPort(FALSE);
	sleep_ack++; 

	initPacket.SetData(warmresetPayload, 18);
	initPacket.header.ack = ack;
	initPacket.header.seq = seq;
	initPacket.header.crcPresent = 0x0;
	initPacket.header.payloadLength = 18;
	initPacket.header.protocolID = 0x2;
	initPacket.header.protocolType = 0x1;
	initPacket.WriteToCOMPort(FALSE);
}