psconfig.cpp

关于S3C2442平台蓝牙模块驱动

	
	//RETAILMSG(1,(TEXT("ConfigResetPDU---\n")));
	//free(p );
	return;
}

/*
// Setup connection
//  Presently assumes COM port driver loaded
BOOL Initialise(char *arg)
{
  DCB config;
  COMMTIMEOUTS timeouts;

	// Open the com port required
	com_handle = CreateFile((LPCTSTR)arg, GENERIC_READ | GENERIC_WRITE, 0, 0,
		                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

	if (com_handle == INVALID_HANDLE_VALUE)
	{
		RETAILMSG(1,(TEXT("Cannot open com port\n")));
		return FALSE;
	}

	// Null structure contents
	memset (&config, 0, sizeof (config));

	// Build Comm DCB 
        config.BaudRate = 115200;
	config.Parity   = 2;                 // 2='E'
	config.ByteSize = 8;
	config.StopBits = 0;                 // 0=1

	// Setup the com port state
	if(!SetCommState (com_handle, &config))
        return FALSE;

	// Setup the com port timeouts
	timeouts.ReadIntervalTimeout         = MAXDWORD;
	timeouts.ReadTotalTimeoutConstant    = 0;
	timeouts.ReadTotalTimeoutMultiplier  = 0;
	timeouts.WriteTotalTimeoutConstant   = 0;
	timeouts.WriteTotalTimeoutMultiplier = 0;
	if(!SetCommTimeouts(com_handle, &timeouts))
        return FALSE;

	// Setup the fifo depth
	if(!SetupComm (com_handle, 16, 16))
    return FALSE;

  return TRUE;
}
*/

void GetReceiveState(struct ubcsp_packet *rx_packet, unsigned char *rx_buffer)
{
	// Only print out BCCMD information
	if(rx_packet->channel == BCCMD)
	{
		switch(rx_buffer[0] & 0xFF)
		{ 
			case 0x01:
			{
				//OutputDebugString(_T("BCCMD COMMAND RECEIVED = "));
				PrintData(rx_buffer, rx_packet->length);

				// Check to see if Command Complete is the PS from TX Queue
				// If it is allow next BCCMD Message
				if(((rx_buffer[6] & 0xFF) == uBCSP_TXQueue.Opcode[0])
						&& ((rx_buffer[7] & 0xFF) == uBCSP_TXQueue.Opcode[1]))
				{
					//OutputDebugString(_T("COMMAND COMPLETE\r\n"));
					uBCSP_TXQueue.CommandNumber = SENT_STATE;
					uBCSP_TXQueue.NoOfOpcodes = 0;
				}
				else
				{
					OutputDebugString(_T("WARNING: COMMAND DOES NOT MATCH QUEUE\r\n"));
				}
			}
			break;

			case 0x05:
			{
				// Output to Debug any disconnection attempts
				OutputDebugString(_T("DISCONNECTION COMPLETE\r\n"));
				PrintData(rx_buffer, rx_packet->length);
			}
			break;
							
			case 0x10:
			{
				// Output to Debug any detected error messages
				OutputDebugString(_T("WARNING: HARDWARE ERROR:\r\n"));
				PrintData(rx_buffer, rx_packet->length);
			}
			break;

			case 0x0f:
			{
				//printf("COMMAND STATUS: ");
				OutputDebugString(_T("COMMAND STATUS:\r\n"));
				PrintData(rx_buffer, rx_packet->length);
			}
			break;  
      
			default:
			{
				// Output to Debug any other message
				//OutputDebugString(_T("UNKNOWN COMMAND:\r\n"));
				PrintData(rx_buffer, rx_packet->length);
				
			}
		}
	}
	else
	{
		// Reset received
   		if(rx_packet->channel == HCI_COMMAND && (rx_buffer[0] & 0xFF) == 0x0f )
   		//if(rx_packet->channel == BCCMD && (rx_buffer[0] & 0xFF) == 0x0f )
		{
			if(giPDUIndex == giPDUCount)
			{
				OutputDebugString(_T("Reset complete\r\n"));
				uBCSP_TXQueue.CommandNumber = EXIT_STATE;
			}
		}
		else
		{
			// Check any data received on other channels
//			OutputDebugString("\n|_WARNING: DATA RECEIVED ON NON BCCMD CHANNEL:");
//			sprintf(sTemp, "\n|_Packet Received, Channel = %02x ", rx_packet->channel);
//			OutputDebugString(sTemp);
//			OutputDebugString("\n|_Data: ");
//			PrintData(rx_buffer, rx_packet->length);
		}
	}

	// Allow another packet to be received up to 512 bytes long
	rx_packet->length = 512;
	memset(rx_packet->payload, 0, 512);

	// Setup the receive again 
	ubcsp_receive_packet(rx_packet);
}

void GetSentState(struct ubcsp_packet *sd_packet)
{
	static uint8 i, j;
	int iLength;
	//char sTemp[24];

	// Write data
	//OutputDebugString(_T("\nWRITING DATA UNIT\n------------------\n"));

	// Construct uBCSP packet header from PDU - ensures correct byte ordering
	// Header
	sd_packet->payload[0] = (uint8)gPDU[giPDUIndex].type;
	sd_packet->payload[1] = (uint8)(gPDU[giPDUIndex].type >> 8);
	sd_packet->payload[2] = (uint8)gPDU[giPDUIndex].pdulen;
	sd_packet->payload[3] = (uint8)(gPDU[giPDUIndex].pdulen >> 8);
	sd_packet->payload[4] = (uint8)gPDU[giPDUIndex].seqno;
	sd_packet->payload[5] = (uint8)(gPDU[giPDUIndex].seqno >> 8);
	sd_packet->payload[6] = (uint8)gPDU[giPDUIndex].varid;
	sd_packet->payload[7] = (uint8)(gPDU[giPDUIndex].varid >> 8);
	sd_packet->payload[8] = (uint8)gPDU[giPDUIndex].status;
	sd_packet->payload[9] = (uint8)(gPDU[giPDUIndex].status >> 8);

	// PS specific
	sd_packet->payload[10] = (uint8)gPDU[giPDUIndex].d.ps.id;
	sd_packet->payload[11] = (uint8)(gPDU[giPDUIndex].d.ps.id >> 8);
	sd_packet->payload[12] = (uint8)gPDU[giPDUIndex].d.ps.len;
	sd_packet->payload[13] = (uint8)(gPDU[giPDUIndex].d.ps.len >> 8);
	sd_packet->payload[14] = (uint8)gPDU[giPDUIndex].d.ps.stores;
	sd_packet->payload[15] = (uint8)(gPDU[giPDUIndex].d.ps.stores >> 8);
      
	// Data
	j = 16;
	for(i = 0; i < gPDU[giPDUIndex].d.ps.len; i++)
	{
		sd_packet->payload[i + j]     = (uint8)gPDU[giPDUIndex].d.ps.psmem[i];    
		sd_packet->payload[i + j + 1] = (uint8)(gPDU[giPDUIndex].d.ps.psmem[i] >> 8);
		j++;
	}

	// Packet length
	iLength = 15 + (gPDU[giPDUIndex].d.ps.len * sizeof(uint16)) + 1;
	sd_packet->length = iLength;
  
	// Set packet defaults
	sd_packet->channel  = BCCMD;
	sd_packet->reliable = RELIABLE;
	sd_packet->use_crc  = TRUE;

	// Configure uBCSP queue handler
	uBCSP_TXQueue.NoOfRetries   = 0;
	uBCSP_TXQueue.Opcode[0]     = sd_packet->payload[6]; 
	uBCSP_TXQueue.Opcode[1]     = sd_packet->payload[7]; 
	uBCSP_TXQueue.CommandNumber = RECEIVED_STATE;
	uBCSP_TXQueue.NoOfOpcodes   = 1;

	// Send the Transmit Packet
	ubcsp_send_packet(sd_packet);
	giPDUIndex++;                              // Increase pdu index
	if(giPDUIndex == giPDUCount)               // Temp
		{
		//BT_DBGMSG(TEXT("@@ sent reset pkg !!!!\r\n"));
		giResetSent = 1;
		}

        // Some Debug Information
	//OutputDebugString(_T("\nBCCMD COMMAND SENT     = ")); 
	for (i = 0; i < sd_packet->length; i++)
	{
		//sprintf(sTemp, "%02x ", sd_packet->payload[i]);
		//#ifdef _WIN32_WCE
			//OutputDebugString((wchar_t*)sTemp);
		//#else
			//OutputDebugString(sTemp);
		//#endif
		RETAILMSG(PS_DBG,(TEXT("0x%02x "),sd_packet->payload[i]));
	}
	//OutputDebugString(_T("\n"));
}

void ExitMod()
{
	// Delete global pdu array
	delete [] gPDU;
       
	// Exiting
	//OutputDebugString(_T("Exiting Update CSRPSKey Function\r\n"));

	return;
}

void ExitMod_A()
{    
	
	// Exiting
	//OutputDebugString(_T("Exiting Set TESTMode Function\r\n"));
	//BT_DBGMSG(TEXT("Exit test mode\r\n"));

	return;
}

//////////////////////////////////////////////////////////////////////////
// Called externally by uBCSP
//
void put_uart (uint8 ch)
{
	unsigned long lWritten = 0;
	lWritten = CSR_Write(ghPort, &ch, 1);
}

// Called externally by uBCSP
uint8 get_uart (uint8 *ch)
{
	static uint8 fifo_buffer[256];
	static uint8 read_index = 0, write_index = 0;
	unsigned long lDummy = 0, lRead = 0;

	// Read the UART in large chunks
	if (read_index == write_index)
	{
		read_index = 0;
		write_index = 0;

		// Read 254 octets
		unsigned long int lRead = CSR_Read(ghPort, fifo_buffer, 254, &lDummy);
		//NKDbgPrintfW(TEXT(" Read result=%x readnum=%x\r\n"),lRead,lDummy);	 	
		if(lRead > 0)
		{
			write_index += (uint8)lRead;

			// Read the first octet returned
			*ch = fifo_buffer[read_index ++];

			return 1;
		}
	}
	else
	{
		// Read the next octet in the fifo_buffer
		*ch = fifo_buffer[read_index ++];	
		//NKDbgPrintfW(TEXT(" 2\r\n"));	 	

		return 1;
	}
	//NKDbgPrintfW(TEXT(" 3\r\n"));	 	
	return 0;
}

//////////////////////////////////////////////////////////////////////////
//  Miscellaneous functions
//
void PrintData(unsigned char *data, int length)
{
	static int i;
	//char sTemp[48];
	int iLen;

	// Size to max packet length
	iLen = 15 + gPDU[giPDUIndex-1].d.ps.len * sizeof(uint16) + 1;
	for (i = 0; i < iLen; i++)
	{
		/*sprintf(sTemp, "%02x ", data[i] & 0xFF);
		#ifdef _WIN32_WCE
			OutputDebugString((wchar_t*)sTemp);
		#else
			OutputDebugString(sTemp);
		#endif*/
		RETAILMSG(PS_DBG,(TEXT("0x%02x "),data[i] & 0xFF));
	}
	//OutputDebugString(_T("\n"));
}

void PrintData_A(unsigned char *data, int length)
{
     static int i;
   
     for (i = 0; i < length; i++)
     {
     
     	RETAILMSG(PS_DBG,(TEXT("%02x\r\n"), data[i] & 0xFF));
     }
    
}

static int Hex2Int(char c)
{
	if (c >= '0' && c <= '9')
		return c - '0';
	if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	return -1;
}

//Jonathan_test

BOOL TESTMode(HANDLE hPort)
{

	int           iDelay;
	BOOL          bLastSentPacket;
	unsigned char chActivity;
	unsigned char chSendBuffer[512],	chReceiveBuffer[512];
	struct        ubcsp_packet  SendPacket, ReceivePacket;
	
	//BT_DBGMSG(TEXT("PSConfig_TESTMode start\r\n"));
        
	// Construct pdus
	ghPort = hPort;
	
	//InitialiseWindows(ghPort);
	
        ubcsp_initialize ();
        
	// Setup packets payload
	SendPacket.payload          = chSendBuffer;
	ReceivePacket.payload       = chReceiveBuffer;
	ReceivePacket.length        = 512;
       
        // Ask ubcsp to receive a packet
	ubcsp_receive_packet (&ReceivePacket);
	
	HCI_TXQueue.commandnumber = RECEIVED_STATE;
	HCI_TXQueue.NoOfOpcodes = 0;
	HCI_TXQueue.NoOfRetries = 0;
	
	// Start Link establishment timer
        giStartTime  = GetTickCount();
 	
 	bLastSentPacket = FALSE;

        // Enter loop to 'listen' to uBCSP commands
	while(TRUE)
	{
		switch(HCI_TXQueue.commandnumber)
		{
			case POLL_STATE:
			{
				iDelay = ubcsp_poll (&chActivity);
				HCI_TXQueue.commandnumber = RECEIVED_STATE;
				//RETAILMSG(1,(TEXT("POLL_STATE\r\n")));
				
				// Link Init check
				//if((GetTickCount() - giStartTime > LINKTIMEOUT) && !gbLinked)
				//	HCI_TXQueue.commandnumber = EXIT_STATE;   
					

				//if(ubcsp_config.link_establishment_state > 0)
				//	gbLinked = TRUE;
			}
			break;

			case RECEIVED_STATE:
			{
				HCI_TXQueue.commandnumber = PEER_RESET_STATE;
				if(chActivity & UBCSP_PACKET_RECEIVED)
					DecodeReceiveState(&ReceivePacket, chReceiveBuffer);

				if(chActivity & UBCSP_PACKET_SENT)
				{
					// Acknowledge sent package
					if(!bLastSentPacket)
					{
						// Link is established
						RETAILMSG(PS_DBG,(TEXT("PSConfig_TESTMode : Link is now Established\r\n")));
						HCI_TXQueue.commandnumber = SENT_STATE;
							 	
					}	
					bLastSentPacket = TRUE;
				}
			}
			break;

			case SENT_STATE:
			{
				// Returns the appropriate next state
				RETAILMSG(1,(TEXT("SENT_STATE\r\n")));
				
				DecodeSentState(&SendPacket);
//				NKDbgPrintfW(TEXT("D0\r\n"));	 	
				//DecodeSentState_A(&SendPacket);
				//DecodeSentState_B(&SendPacket);
			}
			break;
			
			case SENT_STATEA:
			{
				// Returns the appropriate next state
				//RETAILMSG(1,(TEXT("SENT_STATEA\r\n")));
				
				DecodeSentState_A(&SendPacket);
//				NKDbgPrintfW(TEXT("DA\r\n"));	 	
			}
			break;
			
			case SENT_STATEB:
			{
				// Returns the appropriate next state
				//RETAILMSG(1,(TEXT("SENT_STATEB\r\n")));
				
				DecodeSentState_B(&SendPacket);
//				NKDbgPrintfW(TEXT("DB\r\n"));	 	
			}
			break;

			case PEER_RESET_STATE:
			{
				//NKDbgPrintfW(TEXT("go sleep\r\n"));	 	 
				if((chActivity & UBCSP_PEER_RESET) && giResetSent > 0)
				{
		                       	// This function is wait uBCSP Peer Reset Activity 
		                       	// and Send PSKey PDU finish command, Then will leave 
		                       	// the CSR PSKey Update Function.--Jonathan1223a
		                       	
		                       	
		                       	// Peer reset detected
					RETAILMSG(PS_DBG,(TEXT("PSConfig_TESTMode : uBCSP Peer Reset Received\r\n")));
					HCI_TXQueue.commandnumber = EXIT_STATE;
//					NKDbgPrintfW(TEXT("T exit\r\n"));	 	
					break;
				}
				HCI_TXQueue.commandnumber = SLEEP_STATE;
			}
			break;

			case SLEEP_STATE:
			{