-/*\r
- LUFA Library\r
- Copyright (C) Dean Camera, 2010.\r
- \r
- dean [at] fourwalledcubicle [dot] com\r
- www.fourwalledcubicle.com\r
-*/\r
-\r
-/*\r
- Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
-\r
- Permission to use, copy, modify, distribute, and sell this \r
- software and its documentation for any purpose is hereby granted\r
- without fee, provided that the above copyright notice appear in \r
- all copies and that both that the copyright notice and this\r
- permission notice and warranty disclaimer appear in supporting \r
- documentation, and that the name of the author not be used in \r
- advertising or publicity pertaining to distribution of the \r
- software without specific, written prior permission.\r
-\r
- The author disclaim all warranties with regard to this\r
- software, including all implied warranties of merchantability\r
- and fitness. In no event shall the author be liable for any\r
- special, indirect or consequential damages or any damages\r
- whatsoever resulting from loss of use, data or profits, whether\r
- in an action of contract, negligence or other tortious action,\r
- arising out of or in connection with the use or performance of\r
- this software.\r
-*/\r
-\r
-#define INCLUDE_FROM_BLUETOOTH_ACLPACKETS_C\r
-#include "BluetoothACLPackets.h"\r
-\r
-/** Bluetooth ACL processing task. This task should be called repeatedly the main Bluetooth\r
- * stack task to manage the ACL processing state.\r
- */\r
-void Bluetooth_ACLTask(void)\r
-{\r
- /* Process incomming ACL packets, if any */\r
- Bluetooth_ProcessIncommingACLPackets();\r
- \r
- /* Check for any half-open channels, send configuration details to the remote device if found */\r
- for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)\r
- {\r
- Bluetooth_Channel_t* ChannelData = &Bluetooth_Connection.Channels[i];\r
- \r
- bool MustSendConfigReq = true;\r
- \r
- /* Check if we are in a channel state which requires a configuration request to be sent */\r
- switch (ChannelData->State)\r
- {\r
- case Channel_Config_WaitConfig:\r
- ChannelData->State = Channel_Config_WaitReqResp;\r
- break;\r
- case Channel_Config_WaitSendConfig:\r
- ChannelData->State = Channel_Config_WaitResp;\r
- break;\r
- default:\r
- MustSendConfigReq = false;\r
- break;\r
- }\r
- \r
- /* Only send a configuration request if it the channel was in a state which required it */\r
- if (MustSendConfigReq)\r
- {\r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_ConfigurationReq_t ConfigurationRequest;\r
- \r
- struct\r
- {\r
- BT_Config_Option_Header_t Header;\r
- uint16_t Value;\r
- } Option_LocalMTU;\r
- } PacketData;\r
- \r
- /* Fill out the Signal Command header in the response packet */\r
- PacketData.SignalCommandHeader.Code = BT_SIGNAL_CONFIGURATION_REQUEST;\r
- PacketData.SignalCommandHeader.Identifier = ++Bluetooth_Connection.SignallingIdentifier;\r
- PacketData.SignalCommandHeader.Length = sizeof(PacketData.ConfigurationRequest) +\r
- sizeof(PacketData.Option_LocalMTU);\r
-\r
- /* Fill out the Configuration Request in the response packet, including local MTU information */\r
- PacketData.ConfigurationRequest.DestinationChannel = ChannelData->RemoteNumber;\r
- PacketData.ConfigurationRequest.Flags = 0;\r
- PacketData.Option_LocalMTU.Header.Type = BT_CONFIG_OPTION_MTU;\r
- PacketData.Option_LocalMTU.Header.Length = sizeof(PacketData.Option_LocalMTU.Value);\r
- PacketData.Option_LocalMTU.Value = ChannelData->LocalMTU;\r
-\r
- Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);\r
- \r
- BT_ACL_DEBUG(1, ">> L2CAP Configuration Request", NULL);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", PacketData.ConfigurationRequest.DestinationChannel);\r
- }\r
- }\r
-}\r
-\r
-/** Incomming ACL packet processing task. This task is called by the main ACL processing task to read in and process\r
- * any incomming ACL packets to the device, handling signal requests as they are received or passing along channel\r
- * data to the user application.\r
- */\r
-static void Bluetooth_ProcessIncommingACLPackets(void)\r
-{\r
- BT_ACL_Header_t ACLPacketHeader;\r
- BT_DataPacket_Header_t DataHeader;\r
-\r
- Pipe_SelectPipe(BLUETOOTH_DATA_IN_PIPE);\r
- Pipe_Unfreeze();\r
- \r
- if (!(Pipe_IsReadWriteAllowed()))\r
- {\r
- Pipe_Freeze();\r
- return;\r
- }\r
- \r
- /* Read in the received ACL packet headers when it has been discovered that a packet has been received */\r
- Pipe_Read_Stream_LE(&ACLPacketHeader, sizeof(ACLPacketHeader));\r
- Pipe_Read_Stream_LE(&DataHeader, sizeof(DataHeader));\r
-\r
- BT_ACL_DEBUG(2, "", NULL);\r
- BT_ACL_DEBUG(2, "Packet Received", NULL);\r
- BT_ACL_DEBUG(2, "-- Connection Handle: 0x%04X", (ACLPacketHeader.ConnectionHandle & 0x0FFF));\r
- BT_ACL_DEBUG(2, "-- Data Length: 0x%04X", ACLPacketHeader.DataLength);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DataHeader.DestinationChannel);\r
- BT_ACL_DEBUG(2, "-- Payload Length: 0x%04X", DataHeader.PayloadLength);\r
-\r
- /* Check the packet's destination channel - signalling channel should be processed by the stack internally */\r
- if (DataHeader.DestinationChannel == BT_CHANNEL_SIGNALING)\r
- {\r
- /* Read in the Signal Command header of the incomming packet */\r
- BT_Signal_Header_t SignalCommandHeader;\r
- Pipe_Read_Stream_LE(&SignalCommandHeader, sizeof(SignalCommandHeader));\r
- \r
- /* Dispatch to the appropriate handler function based on the Signal message code */\r
- switch (SignalCommandHeader.Code)\r
- {\r
- case BT_SIGNAL_CONNECTION_REQUEST:\r
- Bluetooth_Signal_ConnectionReq(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_CONNECTION_RESPONSE:\r
- Bluetooth_Signal_ConnectionResp(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_CONFIGURATION_REQUEST:\r
- Bluetooth_Signal_ConfigurationReq(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_CONFIGURATION_RESPONSE:\r
- Bluetooth_Signal_ConfigurationResp(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_DISCONNECTION_REQUEST:\r
- Bluetooth_Signal_DisconnectionReq(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_DISCONNECTION_RESPONSE:\r
- Bluetooth_Signal_DisconnectionResp(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_ECHO_REQUEST:\r
- Bluetooth_Signal_EchoReq(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_INFORMATION_REQUEST:\r
- Bluetooth_Signal_InformationReq(&SignalCommandHeader);\r
- break;\r
- case BT_SIGNAL_COMMAND_REJECT:\r
- BT_ACL_DEBUG(1, "<< Command Reject", NULL);\r
- \r
- uint16_t RejectReason;\r
- Pipe_Read_Stream_LE(&RejectReason, sizeof(RejectReason));\r
- Pipe_Discard_Stream(ACLPacketHeader.DataLength - sizeof(RejectReason));\r
- Pipe_ClearIN();\r
- Pipe_Freeze(); \r
- \r
- BT_ACL_DEBUG(2, "-- Reason: %d", RejectReason);\r
- break;\r
- default:\r
- BT_ACL_DEBUG(1, "<< Unknown Signaling Command 0x%02X", SignalCommandHeader.Code);\r
- \r
- Pipe_Discard_Stream(ACLPacketHeader.DataLength);\r
- Pipe_ClearIN(); \r
- Pipe_Freeze();\r
- break;\r
- }\r
- }\r
- else\r
- {\r
- /* Non-signalling packet received, read in the packet contents and pass to the user application */\r
- uint8_t PacketData[DataHeader.PayloadLength];\r
- Pipe_Read_Stream_LE(PacketData, DataHeader.PayloadLength);\r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
-\r
- Bluetooth_PacketReceived(PacketData, DataHeader.PayloadLength, Bluetooth_GetChannelData(DataHeader.DestinationChannel, false));\r
- }\r
-}\r
-\r
-/** Sends a packet to the remote device on the specified channel.\r
- *\r
- * \param Data Pointer to a buffer where the data is to be sourced from\r
- * \param DataLen Length of the data to send\r
- * \param Channel Channel information structure containing the destination channel's information, NULL to send\r
- * to the remote device's signalling channel\r
- *\r
- * \return A value from the \ref BT_SendPacket_ErrorCodes_t enum\r
- */\r
-uint8_t Bluetooth_SendPacket(void* Data, uint16_t DataLen, Bluetooth_Channel_t* Channel)\r
-{\r
- BT_ACL_Header_t ACLPacketHeader;\r
- BT_DataPacket_Header_t DataHeader;\r
-\r
- /* A remote device must be connected before a packet transmission is attempted */\r
- if (!(Bluetooth_Connection.IsConnected))\r
- return BT_SENDPACKET_NotConnected;\r
-\r
- /* If the destination channel is not the signalling channel and it is not currently fully open, abort */\r
- if ((Channel != NULL) && (Channel->State != Channel_Open))\r
- return BT_SENDPACKET_ChannelNotOpen;\r
-\r
- /* Fill out the packet's header from the remote device connection information structure */\r
- ACLPacketHeader.ConnectionHandle = (Bluetooth_Connection.ConnectionHandle | BT_ACL_FIRST_AUTOFLUSH);\r
- ACLPacketHeader.DataLength = sizeof(DataHeader) + DataLen;\r
- DataHeader.PayloadLength = DataLen;\r
- DataHeader.DestinationChannel = (Channel == NULL) ? BT_CHANNEL_SIGNALING : Channel->RemoteNumber;\r
-\r
- Pipe_SelectPipe(BLUETOOTH_DATA_OUT_PIPE);\r
- Pipe_Unfreeze();\r
- \r
- /* Write the packet contents to the pipe so that it can be sent to the remote device */\r
- Pipe_Write_Stream_LE(&ACLPacketHeader, sizeof(ACLPacketHeader));\r
- Pipe_Write_Stream_LE(&DataHeader, sizeof(DataHeader));\r
- Pipe_Write_Stream_LE(Data, DataLen);\r
- Pipe_ClearOUT();\r
- \r
- Pipe_Freeze();\r
- \r
- BT_ACL_DEBUG(2, "", NULL);\r
- BT_ACL_DEBUG(2, "Packet Sent", NULL);\r
- BT_ACL_DEBUG(2, "-- Connection Handle: 0x%04X", (ACLPacketHeader.ConnectionHandle & 0x0FFF));\r
- BT_ACL_DEBUG(2, "-- Data Length: 0x%04X", ACLPacketHeader.DataLength);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DataHeader.DestinationChannel);\r
- BT_ACL_DEBUG(2, "-- Payload Length: 0x%04X", DataHeader.PayloadLength);\r
-\r
- return BT_SENDPACKET_NoError;\r
-}\r
-\r
-/** Opens a bluetooth channel to the currently connected remote device, so that data can be exchanged.\r
- *\r
- * \note The channel is not immediately opened when this function returns - it must undergo a two way\r
- * connection and configuration process first as the main Bluetooth stack processing task is\r
- * repeatedly called. The returned channel is unusable by the user application until its State\r
- * element has progressed to the Open state.\r
- *\r
- * \param PSM PSM of the service that the channel is to be opened for\r
- *\r
- * \return Pointer to the channel information structure of the opened channel, or NULL if no free channels\r
- */\r
-Bluetooth_Channel_t* Bluetooth_OpenChannel(uint16_t PSM)\r
-{\r
- Bluetooth_Channel_t* ChannelData = NULL;\r
-\r
- /* Search through the channel information list for a free channel item */\r
- for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)\r
- {\r
- if (Bluetooth_Connection.Channels[i].State == Channel_Closed)\r
- {\r
- ChannelData = &Bluetooth_Connection.Channels[i];\r
- \r
- /* Set the new channel structure's local channel number to a unique value within the connection orientated\r
- channel address space */\r
- ChannelData->LocalNumber = (BT_CHANNELNUMBER_BASEOFFSET + i);\r
- break;\r
- }\r
- }\r
-\r
- /* If no free channel item was found in the list, all channels are occupied - abort */\r
- if (ChannelData == NULL)\r
- return NULL;\r
-\r
- /* Reset and fill out the allocated channel's information structure with defaults */\r
- ChannelData->RemoteNumber = 0;\r
- ChannelData->PSM = PSM;\r
- ChannelData->LocalMTU = MAXIMUM_CHANNEL_MTU;\r
- ChannelData->State = Channel_WaitConnectRsp;\r
- \r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_ConnectionReq_t ConnectionRequest;\r
- } PacketData;\r
-\r
- /* Fill out the Signal Command header in the response packet */\r
- PacketData.SignalCommandHeader.Code = BT_SIGNAL_CONNECTION_REQUEST;\r
- PacketData.SignalCommandHeader.Identifier = ++Bluetooth_Connection.SignallingIdentifier;\r
- PacketData.SignalCommandHeader.Length = sizeof(PacketData.ConnectionRequest);\r
- \r
- /* Fill out the Connection Request in the response packet */\r
- PacketData.ConnectionRequest.PSM = PSM;\r
- PacketData.ConnectionRequest.SourceChannel = ChannelData->LocalNumber;\r
- \r
- Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);\r
-\r
- BT_ACL_DEBUG(1, ">> L2CAP Connection Request", NULL);\r
- BT_ACL_DEBUG(2, "-- PSM 0x%04X", PacketData.ConnectionRequest.PSM);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", PacketData.ConnectionRequest.SourceChannel);\r
-\r
- return ChannelData;\r
-}\r
-\r
-/** Closes a bluetooth channel that is open to the currently connected remote device, so that no further data\r
- * can be exchanged.\r
- *\r
- * \note The channel is not immediately closed when this function returns - it must undergo an asynchronous\r
- * disconnection process first as the main Bluetooth stack processing task is repeatedly called. The\r
- * returned channel is unusable by the user application upon return however the channel is not completely\r
- * closed until its State element has progressed to the Closed state.\r
- *\r
- * \param Channel Channel information structure of the channel to close\r
- */\r
-void Bluetooth_CloseChannel(Bluetooth_Channel_t* Channel)\r
-{\r
- /* Don't try to close a non-existing or already closed channel */\r
- if ((Channel == NULL) || (Channel->State == Channel_Closed))\r
- return;\r
-\r
- /* Set the channel's state to the start of the teardown process */\r
- Channel->State = Channel_WaitDisconnect;\r
-\r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_DisconnectionReq_t DisconnectionRequest;\r
- } PacketData;\r
- \r
- /* Fill out the Signal Command header in the response packet */\r
- PacketData.SignalCommandHeader.Code = BT_SIGNAL_DISCONNECTION_REQUEST;\r
- PacketData.SignalCommandHeader.Identifier = ++Bluetooth_Connection.SignallingIdentifier;\r
- PacketData.SignalCommandHeader.Length = sizeof(PacketData.DisconnectionRequest);\r
-\r
- /* Fill out the Disconnection Request in the response packet */\r
- PacketData.DisconnectionRequest.DestinationChannel = Channel->RemoteNumber;\r
- PacketData.DisconnectionRequest.SourceChannel = Channel->LocalNumber;\r
-\r
- Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);\r
- \r
- BT_ACL_DEBUG(1, ">> L2CAP Disconnection Request", NULL);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", PacketData.DisconnectionRequest.DestinationChannel); \r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", PacketData.DisconnectionRequest.SourceChannel); \r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for a Connection Request command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_ConnectionReq(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_ConnectionReq_t ConnectionRequest;\r
- \r
- Pipe_Read_Stream_LE(&ConnectionRequest, sizeof(ConnectionRequest));\r
-\r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
-\r
- BT_ACL_DEBUG(1, "<< L2CAP Connection Request", NULL);\r
- BT_ACL_DEBUG(2, "-- PSM: 0x%04X", ConnectionRequest.PSM);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionRequest.SourceChannel);\r
- \r
- /* Try to retrieve the existing channel's information structure if it exists */\r
- Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionRequest.SourceChannel, true);\r
-\r
- /* If an existing channel item with the correct remote channel number was not found, find a free channel entry */\r
- if (ChannelData == NULL)\r
- {\r
- /* Look through the channel information list for a free entry */\r
- for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)\r
- {\r
- if (Bluetooth_Connection.Channels[i].State == Channel_Closed)\r
- {\r
- ChannelData = &Bluetooth_Connection.Channels[i];\r
-\r
- /* Set the new channel structure's local channel number to a unique value within the connection orientated\r
- channel address space */\r
- ChannelData->LocalNumber = (BT_CHANNELNUMBER_BASEOFFSET + i);\r
- break;\r
- }\r
- }\r
- }\r
-\r
- /* Reset the channel item contents only if a channel entry was found for it */\r
- if (ChannelData != NULL)\r
- {\r
- ChannelData->RemoteNumber = ConnectionRequest.SourceChannel;\r
- ChannelData->PSM = ConnectionRequest.PSM;\r
- ChannelData->LocalMTU = MAXIMUM_CHANNEL_MTU;\r
- ChannelData->State = Channel_Config_WaitConfig;\r
- }\r
- \r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_ConnectionResp_t ConnectionResponse;\r
- } ResponsePacket;\r
-\r
- /* Fill out the Signal Command header in the response packet */\r
- ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_CONNECTION_RESPONSE;\r
- ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;\r
- ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.ConnectionResponse);\r
-\r
- /* Fill out the Connection Response in the response packet */\r
- ResponsePacket.ConnectionResponse.DestinationChannel = ChannelData->LocalNumber;\r
- ResponsePacket.ConnectionResponse.SourceChannel = ChannelData->RemoteNumber;\r
- ResponsePacket.ConnectionResponse.Result = (ChannelData == NULL) ? BT_CONNECTION_REFUSED_RESOURCES :\r
- BT_CONNECTION_SUCCESSFUL;\r
- ResponsePacket.ConnectionResponse.Status = 0x00;\r
- \r
- Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);\r
-\r
- BT_ACL_DEBUG(1, ">> L2CAP Connection Response", NULL);\r
- BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.ConnectionResponse.Result);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ResponsePacket.ConnectionResponse.DestinationChannel);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.ConnectionResponse.SourceChannel);\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for a Connection Response command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_ConnectionResp(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_ConnectionResp_t ConnectionResponse;\r
- \r
- Pipe_Read_Stream_LE(&ConnectionResponse, sizeof(ConnectionResponse));\r
-\r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
-\r
- BT_ACL_DEBUG(1, "<< L2CAP Connection Response", NULL);\r
- BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConnectionResponse.Result); \r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionResponse.SourceChannel); \r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConnectionResponse.DestinationChannel); \r
-\r
- /* Search for the referenced channel in the channel information list */\r
- Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionResponse.SourceChannel, false);\r
-\r
- /* Only progress if the referenced channel data was found */\r
- if (ChannelData != NULL)\r
- {\r
- /* Set the channel structure's remote channel number to the channel allocated on the remote device */\r
- ChannelData->RemoteNumber = ConnectionResponse.SourceChannel;\r
- ChannelData->State = (ConnectionResponse.Result == BT_CONNECTION_SUCCESSFUL) ?\r
- Channel_Config_WaitConfig : Channel_Closed;\r
- }\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for a Configuration Request command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_ConfigurationReq(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_ConfigurationReq_t ConfigurationRequest;\r
- \r
- /* Allocate a buffer large enough to hold the variable number of configuration options in the request */\r
- uint8_t OptionsLen = (SignalCommandHeader->Length - sizeof(ConfigurationRequest));\r
- uint8_t Options[OptionsLen];\r
-\r
- Pipe_Read_Stream_LE(&ConfigurationRequest, sizeof(ConfigurationRequest)); \r
- Pipe_Read_Stream_LE(&Options, sizeof(Options));\r
-\r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
-\r
- /* Search for the referenced channel in the channel information list */\r
- Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConfigurationRequest.DestinationChannel, false);\r
-\r
- BT_ACL_DEBUG(1, "<< L2CAP Configuration Request", NULL);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConfigurationRequest.DestinationChannel);\r
- BT_ACL_DEBUG(2, "-- Remote MTU: 0x%04X", ChannelData->RemoteMTU);\r
- BT_ACL_DEBUG(2, "-- Options Len: 0x%04X", OptionsLen);\r
-\r
- /* Only look at the channel configuration options if a valid channel entry for the local channel number was found */\r
- if (ChannelData != NULL)\r
- {\r
- /* Iterate through each option in the configuration request to look for ones which can be processed */\r
- uint8_t OptionPos = 0;\r
- while (OptionPos < OptionsLen)\r
- {\r
- BT_Config_Option_Header_t* OptionHeader = (BT_Config_Option_Header_t*)&Options[OptionPos];\r
- void* OptionData = &Options[OptionPos + sizeof(*OptionHeader)];\r
-\r
- BT_ACL_DEBUG(2, "-- Option Type: 0x%04X", OptionHeader->Type);\r
- BT_ACL_DEBUG(2, "-- Option Length: 0x%04X", (sizeof(*OptionHeader) + OptionHeader->Length));\r
- \r
- /* Store the remote MTU option's value if present */\r
- if (OptionHeader->Type == BT_CONFIG_OPTION_MTU)\r
- ChannelData->RemoteMTU = *((uint16_t*)OptionData);\r
-\r
- /* Progress to the next option in the packet */\r
- OptionPos += (sizeof(*OptionHeader) + OptionHeader->Length);\r
- }\r
- }\r
- \r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_ConfigurationResp_t ConfigurationResponse;\r
- } ResponsePacket;\r
-\r
- /* Fill out the Signal Command header in the response packet */\r
- ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_CONFIGURATION_RESPONSE;\r
- ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;\r
- ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.ConfigurationResponse);\r
-\r
- /* Fill out the Configuration Response in the response packet */\r
- ResponsePacket.ConfigurationResponse.SourceChannel = ChannelData->RemoteNumber;\r
- ResponsePacket.ConfigurationResponse.Flags = 0x00;\r
- ResponsePacket.ConfigurationResponse.Result = (ChannelData != NULL) ? BT_CONFIGURATION_SUCCESSFUL : BT_CONFIGURATION_REJECTED;\r
-\r
- Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);\r
-\r
- if (ChannelData != NULL)\r
- {\r
- switch (ChannelData->State)\r
- {\r
- case Channel_Config_WaitConfig:\r
- ChannelData->State = Channel_Config_WaitSendConfig;\r
- break;\r
- case Channel_Config_WaitReqResp:\r
- ChannelData->State = Channel_Config_WaitResp;\r
- break;\r
- case Channel_Config_WaitReq:\r
- ChannelData->State = Channel_Open;\r
- break;\r
- }\r
- }\r
-\r
- BT_ACL_DEBUG(1, ">> L2CAP Configuration Response", NULL);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.ConfigurationResponse.SourceChannel);\r
- BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.ConfigurationResponse.Result);\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for a Configuration Response command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_ConfigurationResp(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_ConfigurationResp_t ConfigurationResponse;\r
-\r
- Pipe_Read_Stream_LE(&ConfigurationResponse, sizeof(ConfigurationResponse));\r
-\r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
- \r
- BT_ACL_DEBUG(1, "<< L2CAP Configuration Response", NULL);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConfigurationResponse.SourceChannel);\r
- BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConfigurationResponse.Result);\r
-\r
- /* Search for the referenced channel in the channel information list */\r
- Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConfigurationResponse.SourceChannel, true);\r
- \r
- /* Only update the channel's state if it was found in the channel list */\r
- if (ChannelData != NULL)\r
- {\r
- /* Check if the channel configuration completed successfuly */\r
- if (ConfigurationResponse.Result == BT_CONFIGURATION_SUCCESSFUL)\r
- {\r
- switch (ChannelData->State)\r
- {\r
- case Channel_Config_WaitReqResp:\r
- ChannelData->State = Channel_Config_WaitReq;\r
- break;\r
- case Channel_Config_WaitResp:\r
- ChannelData->State = Channel_Open;\r
- break;\r
- } \r
- }\r
- else\r
- {\r
- /* Configuration failed - close the channel */\r
- ChannelData->State = Channel_Closed;\r
- }\r
- }\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for a Disconnection Request command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_DisconnectionReq(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_DisconnectionReq_t DisconnectionRequest;\r
- \r
- Pipe_Read_Stream_LE(&DisconnectionRequest, sizeof(DisconnectionRequest));\r
-\r
- BT_ACL_DEBUG(1, "<< L2CAP Disconnection Request", NULL);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DisconnectionRequest.DestinationChannel);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", DisconnectionRequest.SourceChannel);\r
- \r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
- \r
- /* Search for the referenced channel in the channel information list */\r
- Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(DisconnectionRequest.SourceChannel, true);\r
-\r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_DisconnectionResp_t DisconnectionResponse;\r
- } ResponsePacket;\r
-\r
- /* Fill out the Signal Command header in the response packet */\r
- ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_DISCONNECTION_RESPONSE;\r
- ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;\r
- ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.DisconnectionResponse);\r
-\r
- /* Fill out the Disconnection Response in the response packet */\r
- ResponsePacket.DisconnectionResponse.DestinationChannel = ChannelData->RemoteNumber;\r
- ResponsePacket.DisconnectionResponse.SourceChannel = ChannelData->LocalNumber;\r
-\r
- Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);\r
-\r
- /* If the channel was found in the channel list, close it */\r
- if (ChannelData != NULL)\r
- ChannelData->State = Channel_Closed;\r
-\r
- BT_ACL_DEBUG(1, ">> L2CAP Disconnection Response", NULL);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.DisconnectionResponse.SourceChannel);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ResponsePacket.DisconnectionResponse.DestinationChannel);\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for a Disconnection Response command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_DisconnectionResp(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_DisconnectionResp_t DisconnectionResponse;\r
- \r
- Pipe_Read_Stream_LE(&DisconnectionResponse, sizeof(DisconnectionResponse));\r
-\r
- BT_ACL_DEBUG(1, "<< L2CAP Disconnection Response", NULL);\r
- BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DisconnectionResponse.DestinationChannel);\r
- BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", DisconnectionResponse.SourceChannel);\r
- \r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
- \r
- /* Search for the referenced channel in the channel information list */\r
- Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(DisconnectionResponse.SourceChannel, true);\r
- \r
- /* If the channel was found in the channel list, close it */ \r
- if (ChannelData != NULL)\r
- ChannelData->State = Channel_Closed;\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for an Echo Request command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_EchoReq(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_ACL_DEBUG(1, "<< L2CAP Echo Request", NULL);\r
- \r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
- \r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- } ResponsePacket;\r
-\r
- /* Fill out the Signal Command header in the response packet */\r
- ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_ECHO_RESPONSE;\r
- ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;\r
- ResponsePacket.SignalCommandHeader.Length = 0;\r
- \r
- Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);\r
-\r
- BT_ACL_DEBUG(1, ">> L2CAP Echo Response", NULL);\r
-}\r
-\r
-/** Internal Bluetooth stack Signal Command processing routine for an Information Request command.\r
- *\r
- * \param SignalCommandHeader Pointer to the start of the received packet's Signal Command header\r
- */\r
-static inline void Bluetooth_Signal_InformationReq(BT_Signal_Header_t* SignalCommandHeader)\r
-{\r
- BT_Signal_InformationReq_t InformationRequest;\r
-\r
- Pipe_Read_Stream_LE(&InformationRequest, sizeof(InformationRequest));\r
-\r
- BT_ACL_DEBUG(1, "<< L2CAP Information Request", NULL);\r
- BT_ACL_DEBUG(2, "-- Info Type: 0x%04X", InformationRequest.InfoType);\r
- \r
- Pipe_ClearIN();\r
- Pipe_Freeze();\r
-\r
- struct\r
- {\r
- BT_Signal_Header_t SignalCommandHeader;\r
- BT_Signal_InformationResp_t InformationResponse;\r
- \r
- uint8_t Data[4];\r
- } ResponsePacket;\r
- \r
- uint8_t DataLen = 0;\r
- \r
- /* Retrieve the requested information and store it in the outgoing packet, if found */\r
- switch (InformationRequest.InfoType)\r
- {\r
- case BT_INFOREQ_MTU: \r
- ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;\r
- DataLen = 2;\r
- \r
- *((uint16_t*)&ResponsePacket.Data) = MAXIMUM_CHANNEL_MTU;\r
- break;\r
- case BT_INFOREQ_EXTENDEDFEATURES:\r
- ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;\r
- DataLen = 4;\r
- \r
- *((uint32_t*)&ResponsePacket.Data) = 0;\r
- break;\r
- default:\r
- ResponsePacket.InformationResponse.Result = BT_INFORMATION_NOTSUPPORTED;\r
- DataLen = 0;\r
- break;\r
- }\r
- \r
- /* Fill out the Signal Command header in the response packet */\r
- ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_INFORMATION_RESPONSE;\r
- ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;\r
- ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.InformationResponse) + DataLen;\r
-\r
- /* Fill out the Information Response in the response packet */\r
- ResponsePacket.InformationResponse.InfoType = InformationRequest.InfoType;\r
- \r
- Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket) - sizeof(ResponsePacket.Data) + DataLen), NULL);\r
-\r
- BT_ACL_DEBUG(1, ">> L2CAP Information Response", NULL); \r
- BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.InformationResponse.Result);\r
-}\r
+/*
+ LUFA Library
+ Copyright (C) Dean Camera, 2012.
+
+ dean [at] fourwalledcubicle [dot] com
+ www.lufa-lib.org
+*/
+
+/*
+ Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+ Permission to use, copy, modify, distribute, and sell this
+ software and its documentation for any purpose is hereby granted
+ without fee, provided that the above copyright notice appear in
+ all copies and that both that the copyright notice and this
+ permission notice and warranty disclaimer appear in supporting
+ documentation, and that the name of the author not be used in
+ advertising or publicity pertaining to distribution of the
+ software without specific, written prior permission.
+
+ The author disclaim all warranties with regard to this
+ software, including all implied warranties of merchantability
+ and fitness. In no event shall the author be liable for any
+ special, indirect or consequential damages or any damages
+ whatsoever resulting from loss of use, data or profits, whether
+ in an action of contract, negligence or other tortious action,
+ arising out of or in connection with the use or performance of
+ this software.
+*/
+
+/** \file
+ *
+ * Bluetooth L2CAP layer management code. This module managed the creation,
+ * configuration and teardown of L2CAP channels, and manages packet reception
+ * and sending to and from other Bluetooth devices.
+ */
+
+/*
+ TODO: Make SendPacket respect receiver's MTU
+ TODO: Make ReceivePacket stitch together MTU fragments (?)
+ */
+
+#define INCLUDE_FROM_BLUETOOTH_ACLPACKETS_C
+#include "BluetoothACLPackets.h"
+
+/** Bluetooth ACL processing task. This task should be called repeatedly the main Bluetooth
+ * stack task to manage the ACL processing state.
+ */
+void Bluetooth_ACLTask(void)
+{
+ /* Process incoming ACL packets, if any */
+ Bluetooth_ProcessIncomingACLPackets();
+
+ /* Check for any half-open channels, send configuration details to the remote device if found */
+ for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
+ {
+ Bluetooth_Channel_t* ChannelData = &Bluetooth_Connection.Channels[i];
+
+ bool MustSendConfigReq = true;
+
+ /* Check if we are in a channel state which requires a configuration request to be sent */
+ switch (ChannelData->State)
+ {
+ case BT_Channel_Config_WaitConfig:
+ ChannelData->State = BT_Channel_Config_WaitReqResp;
+ break;
+ case BT_Channel_Config_WaitSendConfig:
+ ChannelData->State = BT_Channel_Config_WaitResp;
+ break;
+ default:
+ MustSendConfigReq = false;
+ break;
+ }
+
+ /* Only send a configuration request if it the channel was in a state which required it */
+ if (MustSendConfigReq)
+ {
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_ConfigurationReq_t ConfigurationRequest;
+
+ struct
+ {
+ BT_Config_Option_Header_t Header;
+ uint16_t Value;
+ } Option_LocalMTU;
+ } PacketData;
+
+ /* Fill out the Signal Command header in the response packet */
+ PacketData.SignalCommandHeader.Code = BT_SIGNAL_CONFIGURATION_REQUEST;
+ PacketData.SignalCommandHeader.Identifier = ++Bluetooth_Connection.SignalingIdentifier;
+ PacketData.SignalCommandHeader.Length = sizeof(PacketData.ConfigurationRequest) +
+ sizeof(PacketData.Option_LocalMTU);
+
+ /* Fill out the Configuration Request in the response packet, including local MTU information */
+ PacketData.ConfigurationRequest.DestinationChannel = ChannelData->RemoteNumber;
+ PacketData.ConfigurationRequest.Flags = 0;
+ PacketData.Option_LocalMTU.Header.Type = BT_CONFIG_OPTION_MTU;
+ PacketData.Option_LocalMTU.Header.Length = sizeof(PacketData.Option_LocalMTU.Value);
+ PacketData.Option_LocalMTU.Value = ChannelData->LocalMTU;
+
+ Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);
+
+ BT_ACL_DEBUG(1, ">> L2CAP Configuration Request");
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", PacketData.ConfigurationRequest.DestinationChannel);
+ }
+ }
+}
+
+/** Incoming ACL packet processing task. This task is called by the main ACL processing task to read in and process
+ * any incoming ACL packets to the device, handling signal requests as they are received or passing along channel
+ * data to the user application.
+ */
+static void Bluetooth_ProcessIncomingACLPackets(void)
+{
+ BT_ACL_Header_t ACLPacketHeader;
+ BT_DataPacket_Header_t DataHeader;
+
+ Pipe_SelectPipe(BLUETOOTH_DATA_IN_PIPE);
+ Pipe_Unfreeze();
+
+ if (!(Pipe_IsReadWriteAllowed()))
+ {
+ Pipe_Freeze();
+ return;
+ }
+
+ /* Read in the received ACL packet headers when it has been discovered that a packet has been received */
+ Pipe_Read_Stream_LE(&ACLPacketHeader, sizeof(ACLPacketHeader), NULL);
+ Pipe_Read_Stream_LE(&DataHeader, sizeof(DataHeader), NULL);
+
+ BT_ACL_DEBUG(2, "");
+ BT_ACL_DEBUG(2, "Packet Received");
+ BT_ACL_DEBUG(2, "-- Connection Handle: 0x%04X", (ACLPacketHeader.ConnectionHandle & 0x0FFF));
+ BT_ACL_DEBUG(2, "-- Data Length: 0x%04X", ACLPacketHeader.DataLength);
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DataHeader.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Payload Length: 0x%04X", DataHeader.PayloadLength);
+
+ /* Check the packet's destination channel - signaling channel should be processed by the stack internally */
+ if (DataHeader.DestinationChannel == BT_CHANNEL_SIGNALING)
+ {
+ /* Read in the Signal Command header of the incoming packet */
+ BT_Signal_Header_t SignalCommandHeader;
+ Pipe_Read_Stream_LE(&SignalCommandHeader, sizeof(SignalCommandHeader), NULL);
+
+ /* Dispatch to the appropriate handler function based on the Signal message code */
+ switch (SignalCommandHeader.Code)
+ {
+ case BT_SIGNAL_CONNECTION_REQUEST:
+ Bluetooth_Signal_ConnectionReq(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_CONNECTION_RESPONSE:
+ Bluetooth_Signal_ConnectionResp(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_CONFIGURATION_REQUEST:
+ Bluetooth_Signal_ConfigurationReq(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_CONFIGURATION_RESPONSE:
+ Bluetooth_Signal_ConfigurationResp(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_DISCONNECTION_REQUEST:
+ Bluetooth_Signal_DisconnectionReq(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_DISCONNECTION_RESPONSE:
+ Bluetooth_Signal_DisconnectionResp(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_ECHO_REQUEST:
+ Bluetooth_Signal_EchoReq(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_INFORMATION_REQUEST:
+ Bluetooth_Signal_InformationReq(&SignalCommandHeader);
+ break;
+ case BT_SIGNAL_COMMAND_REJECT:
+ BT_ACL_DEBUG(1, "<< Command Reject");
+
+ uint16_t RejectReason;
+ Pipe_Read_Stream_LE(&RejectReason, sizeof(RejectReason), NULL);
+ Pipe_Discard_Stream(ACLPacketHeader.DataLength - sizeof(RejectReason), NULL);
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ BT_ACL_DEBUG(2, "-- Reason: %d", RejectReason);
+ break;
+ default:
+ BT_ACL_DEBUG(1, "<< Unknown Signaling Command 0x%02X", SignalCommandHeader.Code);
+
+ Pipe_Discard_Stream(ACLPacketHeader.DataLength, NULL);
+ Pipe_ClearIN();
+ Pipe_Freeze();
+ break;
+ }
+ }
+ else
+ {
+ /* Non-signaling packet received, read in the packet contents and pass to the user application */
+ uint8_t PacketData[DataHeader.PayloadLength];
+ Pipe_Read_Stream_LE(PacketData, DataHeader.PayloadLength, NULL);
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ Bluetooth_PacketReceived(PacketData, DataHeader.PayloadLength,
+ Bluetooth_GetChannelData(DataHeader.DestinationChannel, CHANNEL_SEARCH_LOCALNUMBER));
+ }
+}
+
+/** Retrieves the channel information structure with the given local or remote channel number from the channel list.
+ *
+ * \param[in] SearchValue Value to search for in the channel structure list
+ * \param[in] SearchKey Key to search within the channel structure, a \c CHANNEL_SEARCH_* mask
+ *
+ * \return Pointer to the matching channel information structure in the channel table if found, NULL otherwise
+ */
+Bluetooth_Channel_t* Bluetooth_GetChannelData(const uint16_t SearchValue,
+ const uint8_t SearchKey)
+{
+ for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
+ {
+ Bluetooth_Channel_t* ChannelData = &Bluetooth_Connection.Channels[i];
+
+ /* Closed channels should be ignored as they are not considered valid data */
+ if (ChannelData->State == BT_Channel_Closed)
+ continue;
+
+ bool FoundMatch = false;
+
+ /* Search the current channel for the search key to see if it matches */
+ switch (SearchKey)
+ {
+ case CHANNEL_SEARCH_LOCALNUMBER:
+ FoundMatch = (SearchValue == ChannelData->LocalNumber);
+ break;
+ case CHANNEL_SEARCH_REMOTENUMBER:
+ FoundMatch = (SearchValue == ChannelData->RemoteNumber);
+ break;
+ case CHANNEL_SEARCH_PSM:
+ FoundMatch = (SearchValue == ChannelData->PSM);
+ break;
+ }
+
+ if (FoundMatch)
+ return ChannelData;
+ }
+
+ return NULL;
+}
+
+/** Sends a packet to the remote device on the specified channel.
+ *
+ * \param[in] Data Pointer to a buffer where the data is to be sourced from
+ * \param[in] DataLen Length of the data to send
+ * \param[in] ACLChannel ACL channel information structure containing the destination channel's information, NULL
+ * to send to the remote device's signaling channel
+ *
+ * \return A value from the \ref BT_SendPacket_ErrorCodes_t enum
+ */
+uint8_t Bluetooth_SendPacket(void* Data,
+ const uint16_t DataLen,
+ Bluetooth_Channel_t* const ACLChannel)
+{
+ BT_ACL_Header_t ACLPacketHeader;
+ BT_DataPacket_Header_t DataHeader;
+
+ /* A remote device must be connected before a packet transmission is attempted */
+ if (!(Bluetooth_Connection.IsConnected))
+ return BT_SENDPACKET_NotConnected;
+
+ /* If the destination channel is not the signaling channel and it is not currently fully open, abort */
+ if ((ACLChannel != NULL) && (ACLChannel->State != BT_Channel_Open))
+ return BT_SENDPACKET_ChannelNotOpen;
+
+ /* Fill out the packet's header from the remote device connection information structure */
+ ACLPacketHeader.ConnectionHandle = (Bluetooth_Connection.ConnectionHandle | BT_ACL_FIRST_AUTOFLUSH);
+ ACLPacketHeader.DataLength = sizeof(DataHeader) + DataLen;
+ DataHeader.PayloadLength = DataLen;
+ DataHeader.DestinationChannel = (ACLChannel == NULL) ? BT_CHANNEL_SIGNALING : ACLChannel->RemoteNumber;
+
+ Pipe_SelectPipe(BLUETOOTH_DATA_OUT_PIPE);
+
+ Pipe_WaitUntilReady();
+ Pipe_Unfreeze();
+
+ /* Write the packet contents to the pipe so that it can be sent to the remote device */
+ Pipe_Write_Stream_LE(&ACLPacketHeader, sizeof(ACLPacketHeader), NULL);
+ Pipe_Write_Stream_LE(&DataHeader, sizeof(DataHeader), NULL);
+ Pipe_Write_Stream_LE(Data, DataLen, NULL);
+ Pipe_ClearOUT();
+
+ Pipe_Freeze();
+
+ BT_ACL_DEBUG(2, "");
+ BT_ACL_DEBUG(2, "Packet Sent");
+ BT_ACL_DEBUG(2, "-- Connection Handle: 0x%04X", (ACLPacketHeader.ConnectionHandle & 0x0FFF));
+ BT_ACL_DEBUG(2, "-- Data Length: 0x%04X", ACLPacketHeader.DataLength);
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DataHeader.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Payload Length: 0x%04X", DataHeader.PayloadLength);
+
+ return BT_SENDPACKET_NoError;
+}
+
+/** Opens a Bluetooth channel to the currently connected remote device, so that data can be exchanged.
+ *
+ * \note The channel is not immediately opened when this function returns - it must undergo a two way
+ * connection and configuration process first as the main Bluetooth stack processing task is
+ * repeatedly called. The returned channel is unusable by the user application until its State
+ * element has progressed to the Open state.
+ *
+ * \param[in] PSM PSM of the service that the channel is to be opened for
+ *
+ * \return Pointer to the channel information structure of the opened channel, or NULL if no free channels
+ */
+Bluetooth_Channel_t* Bluetooth_OpenChannel(const uint16_t PSM)
+{
+ Bluetooth_Channel_t* ChannelData = NULL;
+
+ /* Search through the channel information list for a free channel item */
+ for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
+ {
+ if (Bluetooth_Connection.Channels[i].State == BT_Channel_Closed)
+ {
+ ChannelData = &Bluetooth_Connection.Channels[i];
+
+ /* Set the new channel structure's local channel number to a unique value within the connection orientated
+ channel address space */
+ ChannelData->LocalNumber = (BT_CHANNELNUMBER_BASEOFFSET + i);
+ break;
+ }
+ }
+
+ /* If no free channel item was found in the list, all channels are occupied - abort */
+ if (ChannelData == NULL)
+ return NULL;
+
+ /* Reset and fill out the allocated channel's information structure with defaults */
+ ChannelData->RemoteNumber = 0;
+ ChannelData->PSM = PSM;
+ ChannelData->LocalMTU = MAXIMUM_CHANNEL_MTU;
+ ChannelData->State = BT_Channel_WaitConnectRsp;
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_ConnectionReq_t ConnectionRequest;
+ } PacketData;
+
+ /* Fill out the Signal Command header in the response packet */
+ PacketData.SignalCommandHeader.Code = BT_SIGNAL_CONNECTION_REQUEST;
+ PacketData.SignalCommandHeader.Identifier = ++Bluetooth_Connection.SignalingIdentifier;
+ PacketData.SignalCommandHeader.Length = sizeof(PacketData.ConnectionRequest);
+
+ /* Fill out the Connection Request in the response packet */
+ PacketData.ConnectionRequest.PSM = PSM;
+ PacketData.ConnectionRequest.SourceChannel = ChannelData->LocalNumber;
+
+ Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);
+
+ BT_ACL_DEBUG(1, ">> L2CAP Connection Request");
+ BT_ACL_DEBUG(2, "-- PSM 0x%04X", PacketData.ConnectionRequest.PSM);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", PacketData.ConnectionRequest.SourceChannel);
+
+ return ChannelData;
+}
+
+/** Closes a Bluetooth channel that is open to the currently connected remote device, so that no further data
+ * can be exchanged.
+ *
+ * \note The channel is not immediately closed when this function returns - it must undergo an asynchronous
+ * disconnection process first as the main Bluetooth stack processing task is repeatedly called. The
+ * returned channel is unusable by the user application upon return however the channel is not completely
+ * closed until its State element has progressed to the Closed state.
+ *
+ * \param[in,out] ACLChannel ACL channel information structure of the channel to close
+ */
+void Bluetooth_CloseChannel(Bluetooth_Channel_t* const ACLChannel)
+{
+ /* Don't try to close a non-existing or already closed channel */
+ if ((ACLChannel == NULL) || (ACLChannel->State == BT_Channel_Closed))
+ return;
+
+ /* Set the channel's state to the start of the teardown process */
+ ACLChannel->State = BT_Channel_WaitDisconnect;
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_DisconnectionReq_t DisconnectionRequest;
+ } PacketData;
+
+ /* Fill out the Signal Command header in the response packet */
+ PacketData.SignalCommandHeader.Code = BT_SIGNAL_DISCONNECTION_REQUEST;
+ PacketData.SignalCommandHeader.Identifier = ++Bluetooth_Connection.SignalingIdentifier;
+ PacketData.SignalCommandHeader.Length = sizeof(PacketData.DisconnectionRequest);
+
+ /* Fill out the Disconnection Request in the response packet */
+ PacketData.DisconnectionRequest.DestinationChannel = ACLChannel->RemoteNumber;
+ PacketData.DisconnectionRequest.SourceChannel = ACLChannel->LocalNumber;
+
+ Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);
+
+ BT_ACL_DEBUG(1, ">> L2CAP Disconnection Request");
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", PacketData.DisconnectionRequest.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", PacketData.DisconnectionRequest.SourceChannel);
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for a Connection Request command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_ConnectionReq(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_ConnectionReq_t ConnectionRequest;
+
+ Pipe_Read_Stream_LE(&ConnectionRequest, sizeof(ConnectionRequest), NULL);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ BT_ACL_DEBUG(1, "<< L2CAP Connection Request");
+ BT_ACL_DEBUG(2, "-- PSM: 0x%04X", ConnectionRequest.PSM);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionRequest.SourceChannel);
+
+ /* Try to retrieve the existing channel's information structure if it exists */
+ Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionRequest.SourceChannel, CHANNEL_SEARCH_REMOTENUMBER);
+
+ /* If an existing channel item with the correct remote channel number was not found, find a free channel entry */
+ if (ChannelData == NULL)
+ {
+ /* Look through the channel information list for a free entry */
+ for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
+ {
+ if (Bluetooth_Connection.Channels[i].State == BT_Channel_Closed)
+ {
+ ChannelData = &Bluetooth_Connection.Channels[i];
+
+ /* Set the new channel structure's local channel number to a unique value within the connection orientated
+ channel address space */
+ ChannelData->LocalNumber = (BT_CHANNELNUMBER_BASEOFFSET + i);
+ break;
+ }
+ }
+ }
+
+ uint8_t ChannelStatus = BT_CONNECTION_REFUSED_RESOURCES;
+
+ /* Reset the channel item contents only if a channel entry was found for it */
+ if (ChannelData != NULL)
+ {
+ /* Check if the user application will allow the connection based on its PSM */
+ if (Bluetooth_ChannelConnectionRequest(ConnectionRequest.PSM))
+ {
+ ChannelData->RemoteNumber = ConnectionRequest.SourceChannel;
+ ChannelData->PSM = ConnectionRequest.PSM;
+ ChannelData->LocalMTU = MAXIMUM_CHANNEL_MTU;
+ ChannelData->State = BT_Channel_Config_WaitConfig;
+
+ ChannelStatus = BT_CONNECTION_SUCCESSFUL;
+ }
+ else
+ {
+ ChannelStatus = BT_CONNECTION_REFUSED_PSM;
+ }
+ }
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_ConnectionResp_t ConnectionResponse;
+ } ResponsePacket;
+
+ /* Fill out the Signal Command header in the response packet */
+ ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_CONNECTION_RESPONSE;
+ ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;
+ ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.ConnectionResponse);
+
+ /* Fill out the Connection Response in the response packet */
+ ResponsePacket.ConnectionResponse.DestinationChannel = ChannelData->LocalNumber;
+ ResponsePacket.ConnectionResponse.SourceChannel = ChannelData->RemoteNumber;
+ ResponsePacket.ConnectionResponse.Result = ChannelStatus;
+ ResponsePacket.ConnectionResponse.Status = 0x00;
+
+ Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
+
+ BT_ACL_DEBUG(1, ">> L2CAP Connection Response");
+ BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.ConnectionResponse.Result);
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ResponsePacket.ConnectionResponse.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.ConnectionResponse.SourceChannel);
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for a Connection Response command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_ConnectionResp(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_ConnectionResp_t ConnectionResponse;
+
+ Pipe_Read_Stream_LE(&ConnectionResponse, sizeof(ConnectionResponse), NULL);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ BT_ACL_DEBUG(1, "<< L2CAP Connection Response");
+ BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConnectionResponse.Result);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionResponse.SourceChannel);
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConnectionResponse.DestinationChannel);
+
+ /* Search for the referenced channel in the channel information list */
+ Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionResponse.SourceChannel, CHANNEL_SEARCH_LOCALNUMBER);
+
+ /* Only progress if the referenced channel data was found */
+ if (ChannelData != NULL)
+ {
+ /* Set the channel structure's remote channel number to the channel allocated on the remote device */
+ ChannelData->RemoteNumber = ConnectionResponse.SourceChannel;
+ ChannelData->State = (ConnectionResponse.Result == BT_CONNECTION_SUCCESSFUL) ?
+ BT_Channel_Config_WaitConfig : BT_Channel_Closed;
+ }
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for a Configuration Request command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_ConfigurationReq(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_ConfigurationReq_t ConfigurationRequest;
+
+ /* Allocate a buffer large enough to hold the variable number of configuration options in the request */
+ uint8_t OptionsLen = (SignalCommandHeader->Length - sizeof(ConfigurationRequest));
+ uint8_t Options[OptionsLen];
+
+ Pipe_Read_Stream_LE(&ConfigurationRequest, sizeof(ConfigurationRequest), NULL);
+ Pipe_Read_Stream_LE(&Options, sizeof(Options), NULL);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ /* Search for the referenced channel in the channel information list */
+ Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConfigurationRequest.DestinationChannel, CHANNEL_SEARCH_LOCALNUMBER);
+
+ BT_ACL_DEBUG(1, "<< L2CAP Configuration Request");
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConfigurationRequest.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Options Len: 0x%04X", OptionsLen);
+
+ /* Only look at the channel configuration options if a valid channel entry for the local channel number was found */
+ if (ChannelData != NULL)
+ {
+ /* Iterate through each option in the configuration request to look for ones which can be processed */
+ uint8_t OptionPos = 0;
+ while (OptionPos < OptionsLen)
+ {
+ BT_Config_Option_Header_t* OptionHeader = (BT_Config_Option_Header_t*)&Options[OptionPos];
+ void* OptionData = &Options[OptionPos + sizeof(BT_Config_Option_Header_t)];
+
+ BT_ACL_DEBUG(2, "-- Option Type: 0x%04X", OptionHeader->Type);
+ BT_ACL_DEBUG(2, "-- Option Length: 0x%04X", (sizeof(BT_Config_Option_Header_t) + OptionHeader->Length));
+
+ /* Store the remote MTU option's value if present */
+ if (OptionHeader->Type == BT_CONFIG_OPTION_MTU)
+ ChannelData->RemoteMTU = *((uint16_t*)OptionData);
+
+ /* Progress to the next option in the packet */
+ OptionPos += (sizeof(BT_Config_Option_Header_t) + OptionHeader->Length);
+ }
+ }
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_ConfigurationResp_t ConfigurationResponse;
+ } ResponsePacket;
+
+ /* Fill out the Signal Command header in the response packet */
+ ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_CONFIGURATION_RESPONSE;
+ ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;
+ ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.ConfigurationResponse);
+
+ /* Fill out the Configuration Response in the response packet */
+ ResponsePacket.ConfigurationResponse.SourceChannel = ChannelData->RemoteNumber;
+ ResponsePacket.ConfigurationResponse.Flags = 0x00;
+ ResponsePacket.ConfigurationResponse.Result = (ChannelData != NULL) ? BT_CONFIGURATION_SUCCESSFUL : BT_CONFIGURATION_REJECTED;
+
+ Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
+
+ if (ChannelData != NULL)
+ {
+ switch (ChannelData->State)
+ {
+ case BT_Channel_Config_WaitConfig:
+ ChannelData->State = BT_Channel_Config_WaitSendConfig;
+ break;
+ case BT_Channel_Config_WaitReqResp:
+ ChannelData->State = BT_Channel_Config_WaitResp;
+ break;
+ case BT_Channel_Config_WaitReq:
+ ChannelData->State = BT_Channel_Open;
+ Bluetooth_ChannelOpened(ChannelData);
+ break;
+ }
+ }
+
+ BT_ACL_DEBUG(1, ">> L2CAP Configuration Response");
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.ConfigurationResponse.SourceChannel);
+ BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.ConfigurationResponse.Result);
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for a Configuration Response command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_ConfigurationResp(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_ConfigurationResp_t ConfigurationResponse;
+
+ Pipe_Read_Stream_LE(&ConfigurationResponse, sizeof(ConfigurationResponse), NULL);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ BT_ACL_DEBUG(1, "<< L2CAP Configuration Response");
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConfigurationResponse.SourceChannel);
+ BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConfigurationResponse.Result);
+
+ /* Search for the referenced channel in the channel information list */
+ Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConfigurationResponse.SourceChannel, CHANNEL_SEARCH_REMOTENUMBER);
+
+ /* Only update the channel's state if it was found in the channel list */
+ if (ChannelData != NULL)
+ {
+ /* Check if the channel configuration completed successfully */
+ if (ConfigurationResponse.Result == BT_CONFIGURATION_SUCCESSFUL)
+ {
+ switch (ChannelData->State)
+ {
+ case BT_Channel_Config_WaitReqResp:
+ ChannelData->State = BT_Channel_Config_WaitReq;
+ break;
+ case BT_Channel_Config_WaitResp:
+ ChannelData->State = BT_Channel_Open;
+ Bluetooth_ChannelOpened(ChannelData);
+ break;
+ }
+ }
+ else
+ {
+ /* Configuration failed - close the channel */
+ ChannelData->State = BT_Channel_Closed;
+ }
+ }
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for a Disconnection Request command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_DisconnectionReq(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_DisconnectionReq_t DisconnectionRequest;
+
+ Pipe_Read_Stream_LE(&DisconnectionRequest, sizeof(DisconnectionRequest), NULL);
+
+ BT_ACL_DEBUG(1, "<< L2CAP Disconnection Request");
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DisconnectionRequest.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", DisconnectionRequest.SourceChannel);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ /* Search for the referenced channel in the channel information list */
+ Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(DisconnectionRequest.SourceChannel, CHANNEL_SEARCH_REMOTENUMBER);
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_DisconnectionResp_t DisconnectionResponse;
+ } ResponsePacket;
+
+ /* Fill out the Signal Command header in the response packet */
+ ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_DISCONNECTION_RESPONSE;
+ ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;
+ ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.DisconnectionResponse);
+
+ /* Fill out the Disconnection Response in the response packet */
+ ResponsePacket.DisconnectionResponse.DestinationChannel = ChannelData->RemoteNumber;
+ ResponsePacket.DisconnectionResponse.SourceChannel = ChannelData->LocalNumber;
+
+ Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
+
+ /* If the channel was found in the channel list, close it */
+ if (ChannelData != NULL)
+ ChannelData->State = BT_Channel_Closed;
+
+ BT_ACL_DEBUG(1, ">> L2CAP Disconnection Response");
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.DisconnectionResponse.SourceChannel);
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ResponsePacket.DisconnectionResponse.DestinationChannel);
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for a Disconnection Response command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_DisconnectionResp(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_DisconnectionResp_t DisconnectionResponse;
+
+ Pipe_Read_Stream_LE(&DisconnectionResponse, sizeof(DisconnectionResponse), NULL);
+
+ BT_ACL_DEBUG(1, "<< L2CAP Disconnection Response");
+ BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DisconnectionResponse.DestinationChannel);
+ BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", DisconnectionResponse.SourceChannel);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ /* Search for the referenced channel in the channel information list */
+ Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(DisconnectionResponse.SourceChannel, CHANNEL_SEARCH_REMOTENUMBER);
+
+ /* If the channel was found in the channel list, close it */
+ if (ChannelData != NULL)
+ ChannelData->State = BT_Channel_Closed;
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for an Echo Request command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_EchoReq(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_ACL_DEBUG(1, "<< L2CAP Echo Request");
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ } ResponsePacket;
+
+ /* Fill out the Signal Command header in the response packet */
+ ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_ECHO_RESPONSE;
+ ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;
+ ResponsePacket.SignalCommandHeader.Length = 0;
+
+ Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
+
+ BT_ACL_DEBUG(1, ">> L2CAP Echo Response");
+}
+
+/** Internal Bluetooth stack Signal Command processing routine for an Information Request command.
+ *
+ * \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
+ */
+static inline void Bluetooth_Signal_InformationReq(const BT_Signal_Header_t* const SignalCommandHeader)
+{
+ BT_Signal_InformationReq_t InformationRequest;
+
+ Pipe_Read_Stream_LE(&InformationRequest, sizeof(InformationRequest), NULL);
+
+ BT_ACL_DEBUG(1, "<< L2CAP Information Request");
+ BT_ACL_DEBUG(2, "-- Info Type: 0x%04X", InformationRequest.InfoType);
+
+ Pipe_ClearIN();
+ Pipe_Freeze();
+
+ struct
+ {
+ BT_Signal_Header_t SignalCommandHeader;
+ BT_Signal_InformationResp_t InformationResponse;
+
+ uint8_t Data[4];
+ } ResponsePacket;
+
+ uint8_t DataLen = 0;
+
+ /* Retrieve the requested information and store it in the outgoing packet, if found */
+ switch (InformationRequest.InfoType)
+ {
+ case BT_INFOREQ_MTU:
+ ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;
+ DataLen = 2;
+
+ *((uint16_t*)&ResponsePacket.Data) = MAXIMUM_CHANNEL_MTU;
+ break;
+ case BT_INFOREQ_EXTENDEDFEATURES:
+ ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;
+ DataLen = 4;
+
+ *((uint32_t*)&ResponsePacket.Data) = 0;
+ break;
+ default:
+ ResponsePacket.InformationResponse.Result = BT_INFORMATION_NOTSUPPORTED;
+ DataLen = 0;
+ break;
+ }
+
+ /* Fill out the Signal Command header in the response packet */
+ ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_INFORMATION_RESPONSE;
+ ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;
+ ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.InformationResponse) + DataLen;
+
+ /* Fill out the Information Response in the response packet */
+ ResponsePacket.InformationResponse.InfoType = InformationRequest.InfoType;
+
+ Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket) - sizeof(ResponsePacket.Data) + DataLen), NULL);
+
+ BT_ACL_DEBUG(1, ">> L2CAP Information Response");
+ BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.InformationResponse.Result);
+}
+
projects / pub / USBasp.git / blobdiff