Demos/Host/Incomplete/BluetoothHost/Lib/BluetoothACLPackets.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #define  INCLUDE_FROM_BLUETOOTH_ACLPACKETS_C
  32 #include "BluetoothACLPackets.h"
  33
  34 void Bluetooth_ACLTask(void)
  35 {
  36         Bluetooth_ProcessACLPackets();
  37
  38         for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
  39         {
  40                 Bluetooth_Channel_t* ChannelData = &Bluetooth_Connection.Channels[i];
  41
  42                 bool MustSendConfigReq = true;
  43
  44                 switch (ChannelData->State)
  45                 {
  46                         case Channel_Config_WaitConfig:
  47                                 ChannelData->State = Channel_Config_WaitReqResp;
  48                                 break;
  49                         case Channel_Config_WaitSendConfig:
  50                                 ChannelData->State = Channel_Config_WaitResp;
  51                                 break;
  52                         default:
  53                                 MustSendConfigReq  = false;
  54                                 break;
  55                 }
  56
  57                 if (MustSendConfigReq)
  58                 {
  59                         struct
  60                         {
  61                                 BT_Signal_Header_t           SignalCommandHeader;
  62                                 BT_Signal_ConfigurationReq_t ConfigurationRequest;
  63
  64                                 struct
  65                                 {
  66                                         BT_Config_Option_Header_t Header;
  67                                         uint16_t Value;
  68                                 } Option_LocalMTU;
  69                         } PacketData;
  70
  71                         PacketData.SignalCommandHeader.Code            = BT_SIGNAL_CONFIGURATION_REQUEST;
  72                         PacketData.SignalCommandHeader.Identifier      = ++Bluetooth_Connection.SignallingIdentifier;
  73                         PacketData.SignalCommandHeader.Length          = sizeof(PacketData.ConfigurationRequest) +
  74                                                                          sizeof(PacketData.Option_LocalMTU);
  75                         PacketData.ConfigurationRequest.DestinationChannel = ChannelData->RemoteNumber;
  76                         PacketData.ConfigurationRequest.Flags          = 0;
  77                         PacketData.Option_LocalMTU.Header.Type         = BT_CONFIG_OPTION_MTU;
  78                         PacketData.Option_LocalMTU.Header.Length       = sizeof(PacketData.Option_LocalMTU.Value);
  79                         PacketData.Option_LocalMTU.Value               = ChannelData->LocalMTU;
  80
  81                         Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);
  82
  83                         BT_ACL_DEBUG(1, ">> L2CAP Configuration Request", NULL);
  84                         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", PacketData.ConfigurationRequest.DestinationChannel);
  85                 }
  86         }
  87 }
  88
  89 static void Bluetooth_ProcessACLPackets(void)
  90 {
  91         BT_ACL_Header_t        ACLPacketHeader;
  92         BT_DataPacket_Header_t DataHeader;
  93
  94         Pipe_SelectPipe(BLUETOOTH_DATA_IN_PIPE);
  95         Pipe_Unfreeze();
  96
  97         if (!(Pipe_IsReadWriteAllowed()))
  98         {
  99                 Pipe_Freeze();
 100                 return;
 101         }
 102
 103         Pipe_Read_Stream_LE(&ACLPacketHeader, sizeof(ACLPacketHeader));
 104         Pipe_Read_Stream_LE(&DataHeader, sizeof(DataHeader));
 105
 106         BT_ACL_DEBUG(2, "", NULL);
 107         BT_ACL_DEBUG(2, "Packet Received", NULL);
 108         BT_ACL_DEBUG(2, "-- Connection Handle: 0x%04X", (ACLPacketHeader.ConnectionHandle & 0x0FFF));
 109         BT_ACL_DEBUG(2, "-- Data Length: 0x%04X", ACLPacketHeader.DataLength);
 110         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DataHeader.DestinationChannel);
 111         BT_ACL_DEBUG(2, "-- Payload Length: 0x%04X", DataHeader.PayloadLength);
 112
 113         if (DataHeader.DestinationChannel == BT_CHANNEL_SIGNALING)
 114         {
 115                 BT_Signal_Header_t SignalCommandHeader;
 116                 Pipe_Read_Stream_LE(&SignalCommandHeader, sizeof(SignalCommandHeader));
 117
 118                 switch (SignalCommandHeader.Code)
 119                 {
 120                         case BT_SIGNAL_CONNECTION_REQUEST:
 121                                 Bluetooth_Signal_ConnectionReq(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 122                                 break;
 123                         case BT_SIGNAL_CONNECTION_RESPONSE:
 124                                 Bluetooth_Signal_ConnectionResp(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 125                                 break;
 126                         case BT_SIGNAL_CONFIGURATION_REQUEST:
 127                                 Bluetooth_Signal_ConfigurationReq(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 128                                 break;
 129                         case BT_SIGNAL_CONFIGURATION_RESPONSE:
 130                                 Bluetooth_Signal_ConfigurationResp(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 131                                 break;
 132                         case BT_SIGNAL_DISCONNECTION_REQUEST:
 133                                 Bluetooth_Signal_DisconnectionReq(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 134                                 break;
 135                         case BT_SIGNAL_DISCONNECTION_RESPONSE:
 136                                 Bluetooth_Signal_DisconnectionResp(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 137                                 break;
 138                         case BT_SIGNAL_ECHO_REQUEST:
 139                                 Bluetooth_Signal_EchoReq(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 140                                 break;
 141                         case BT_SIGNAL_INFORMATION_REQUEST:
 142                                 Bluetooth_Signal_InformationReq(&ACLPacketHeader, &DataHeader, &SignalCommandHeader);
 143                                 break;
 144                         default:
 145                                 BT_ACL_DEBUG(1, "<< Unknown Signaling Command 0x%02X", SignalCommandHeader.Code);
 146
 147                                 Pipe_Discard_Stream(ACLPacketHeader.DataLength);
 148                                 Pipe_ClearIN();
 149                                 Pipe_Freeze();
 150                                 break;
 151                 }
 152         }
 153         else
 154         {
 155                 Bluetooth_PacketReceived(&DataHeader.PayloadLength, Bluetooth_GetChannelData(DataHeader.DestinationChannel, false));
 156
 157                 Pipe_SelectPipe(BLUETOOTH_DATA_IN_PIPE);
 158                 Pipe_Discard_Stream(DataHeader.PayloadLength);
 159                 Pipe_ClearIN();
 160                 Pipe_Freeze();
 161         }
 162 }
 163
 164 uint8_t Bluetooth_SendPacket(void* Data, uint16_t DataLen, Bluetooth_Channel_t* Channel)
 165 {
 166         BT_ACL_Header_t        ACLPacketHeader;
 167         BT_DataPacket_Header_t DataHeader;
 168
 169         if (!(Bluetooth_Connection.IsConnected))
 170           return BT_SENDPACKET_NotConnected;
 171
 172         if ((Channel != NULL) && (Channel->State != Channel_Open))
 173           return BT_SENDPACKET_ChannelNotOpen;
 174
 175         // TODO: Add packet fragmentation here after retrieving the device's signal channel MTU
 176
 177         ACLPacketHeader.ConnectionHandle      = (Bluetooth_Connection.ConnectionHandle | BT_ACL_FIRST_AUTOFLUSH);
 178         ACLPacketHeader.DataLength            = sizeof(DataHeader) + DataLen;
 179         DataHeader.PayloadLength              = DataLen;
 180         DataHeader.DestinationChannel         = (Channel == NULL) ? BT_CHANNEL_SIGNALING : Channel->RemoteNumber;
 181
 182         Pipe_SelectPipe(BLUETOOTH_DATA_OUT_PIPE);
 183         Pipe_Unfreeze();
 184
 185         Pipe_Write_Stream_LE(&ACLPacketHeader, sizeof(ACLPacketHeader));
 186         Pipe_Write_Stream_LE(&DataHeader, sizeof(DataHeader));
 187         Pipe_Write_Stream_LE(Data, DataLen);
 188         Pipe_ClearOUT();
 189
 190         Pipe_Freeze();
 191
 192         BT_ACL_DEBUG(2, "", NULL);
 193         BT_ACL_DEBUG(2, "Packet Sent", NULL);
 194         BT_ACL_DEBUG(2, "-- Connection Handle: 0x%04X", (ACLPacketHeader.ConnectionHandle & 0x0FFF));
 195         BT_ACL_DEBUG(2, "-- Data Length: 0x%04X", ACLPacketHeader.DataLength);
 196         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DataHeader.DestinationChannel);
 197         BT_ACL_DEBUG(2, "-- Payload Length: 0x%04X", DataHeader.PayloadLength);
 198
 199         return BT_SENDPACKET_NoError;
 200 }
 201
 202 Bluetooth_Channel_t* Bluetooth_OpenChannel(uint16_t PSM)
 203 {
 204         Bluetooth_Channel_t* ChannelData = NULL;
 205
 206         for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
 207         {
 208                 if (Bluetooth_Connection.Channels[i].State == Channel_Closed)
 209                 {
 210                         ChannelData = &Bluetooth_Connection.Channels[i];
 211                         ChannelData->LocalNumber = (BLUETOOTH_CHANNELNUMBER_BASEOFFSET + i);
 212                         break;
 213                 }
 214         }
 215
 216         if (ChannelData == NULL)
 217           return NULL;
 218
 219         ChannelData->RemoteNumber = 0;
 220         ChannelData->PSM          = PSM;
 221         ChannelData->LocalMTU     = MAXIMUM_CHANNEL_MTU;
 222         ChannelData->State        = Channel_Config_WaitConfig;
 223
 224         struct
 225         {
 226                 BT_Signal_Header_t        SignalCommandHeader;
 227                 BT_Signal_ConnectionReq_t ConnectionRequest;
 228         } PacketData;
 229
 230         PacketData.SignalCommandHeader.Code              = BT_SIGNAL_CONNECTION_REQUEST;
 231         PacketData.SignalCommandHeader.Identifier        = ++Bluetooth_Connection.SignallingIdentifier;
 232         PacketData.SignalCommandHeader.Length            = sizeof(PacketData.ConnectionRequest);
 233         PacketData.ConnectionRequest.PSM                 = PSM;
 234         PacketData.ConnectionRequest.SourceChannel       = ChannelData->LocalNumber;
 235
 236         Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);
 237
 238         BT_ACL_DEBUG(1, ">> L2CAP Connection Request", NULL);
 239         BT_ACL_DEBUG(2, "-- PSM 0x%04X", PacketData.ConnectionRequest.PSM);
 240         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", PacketData.ConnectionRequest.SourceChannel);
 241
 242         return ChannelData;
 243 }
 244
 245 void Bluetooth_CloseChannel(Bluetooth_Channel_t* Channel)
 246 {
 247         if ((Channel == NULL) || (Channel->State == Channel_Closed))
 248           return;
 249
 250         Channel->State = Channel_WaitDisconnect;
 251
 252         struct
 253         {
 254                 BT_Signal_Header_t           SignalCommandHeader;
 255                 BT_Signal_DisconnectionReq_t DisconnectionRequest;
 256         } PacketData;
 257
 258         PacketData.SignalCommandHeader.Code            = BT_SIGNAL_DISCONNECTION_REQUEST;
 259         PacketData.SignalCommandHeader.Identifier      = ++Bluetooth_Connection.SignallingIdentifier;
 260         PacketData.SignalCommandHeader.Length          = sizeof(PacketData.DisconnectionRequest);
 261         PacketData.DisconnectionRequest.DestinationChannel = Channel->RemoteNumber;
 262         PacketData.DisconnectionRequest.SourceChannel = Channel->LocalNumber;
 263
 264         Bluetooth_SendPacket(&PacketData, sizeof(PacketData), NULL);
 265
 266         BT_ACL_DEBUG(1, ">> L2CAP Disconnection Request", NULL);
 267         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", PacketData.DisconnectionRequest.DestinationChannel);
 268         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", PacketData.DisconnectionRequest.SourceChannel);
 269 }
 270
 271 static inline void Bluetooth_Signal_ConnectionReq(BT_ACL_Header_t*        ACLPacketHeader,
 272                                                   BT_DataPacket_Header_t* DataHeader,
 273                                                   BT_Signal_Header_t*     SignalCommandHeader)
 274 {
 275         BT_Signal_ConnectionReq_t ConnectionRequest;
 276
 277         Pipe_Read_Stream_LE(&ConnectionRequest, sizeof(ConnectionRequest));
 278
 279         Pipe_ClearIN();
 280         Pipe_Freeze();
 281
 282         BT_ACL_DEBUG(1, "<< L2CAP Connection Request", NULL);
 283         BT_ACL_DEBUG(2, "-- PSM: 0x%04X", ConnectionRequest.PSM);
 284         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionRequest.SourceChannel);
 285
 286         Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionRequest.SourceChannel, true);
 287
 288         if (ChannelData == NULL)
 289         {
 290                 for (uint8_t i = 0; i < BLUETOOTH_MAX_OPEN_CHANNELS; i++)
 291                 {
 292                         if (Bluetooth_Connection.Channels[i].State == Channel_Closed)
 293                         {
 294                                 ChannelData = &Bluetooth_Connection.Channels[i];
 295                                 ChannelData->LocalNumber = (BLUETOOTH_CHANNELNUMBER_BASEOFFSET + i);
 296                                 break;
 297                         }
 298                 }
 299         }
 300
 301         if (ChannelData != NULL)
 302         {
 303                 ChannelData->RemoteNumber = ConnectionRequest.SourceChannel;
 304                 ChannelData->PSM          = ConnectionRequest.PSM;
 305                 ChannelData->LocalMTU     = MAXIMUM_CHANNEL_MTU;
 306                 ChannelData->State        = Channel_Config_WaitConfig;
 307         }
 308
 309         struct
 310         {
 311                 BT_Signal_Header_t         SignalCommandHeader;
 312                 BT_Signal_ConnectionResp_t ConnectionResponse;
 313         } ResponsePacket;
 314
 315         ResponsePacket.SignalCommandHeader.Code              = BT_SIGNAL_CONNECTION_RESPONSE;
 316         ResponsePacket.SignalCommandHeader.Identifier        = SignalCommandHeader->Identifier;
 317         ResponsePacket.SignalCommandHeader.Length            = sizeof(ResponsePacket.ConnectionResponse);
 318         ResponsePacket.ConnectionResponse.Result             = (ChannelData == NULL) ? BT_CONNECTION_REFUSED_RESOURCES : BT_CONNECTION_SUCCESSFUL;
 319         ResponsePacket.ConnectionResponse.DestinationChannel = ChannelData->RemoteNumber;
 320         ResponsePacket.ConnectionResponse.SourceChannel      = ChannelData->LocalNumber;
 321         ResponsePacket.ConnectionResponse.Status             = 0x00;
 322
 323         Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
 324
 325         BT_ACL_DEBUG(1, ">> L2CAP Connection Response", NULL);
 326         BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.ConnectionResponse.Result);
 327         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ResponsePacket.ConnectionResponse.DestinationChannel);
 328         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.ConnectionResponse.SourceChannel);
 329 }
 330
 331 static inline void Bluetooth_Signal_ConnectionResp(BT_ACL_Header_t* ACLPacketHeader,
 332                                                    BT_DataPacket_Header_t* DataHeader,
 333                                                    BT_Signal_Header_t* SignalCommandHeader)
 334 {
 335         BT_Signal_ConnectionResp_t ConnectionResponse;
 336
 337         Pipe_Read_Stream_LE(&ConnectionResponse, sizeof(ConnectionResponse));
 338
 339         Pipe_ClearIN();
 340         Pipe_Freeze();
 341
 342         BT_ACL_DEBUG(1, "<< L2CAP Connection Response", NULL);
 343         BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConnectionResponse.Result);
 344         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionResponse.SourceChannel);
 345         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConnectionResponse.DestinationChannel);
 346
 347         Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionResponse.DestinationChannel, false);
 348
 349         if (ChannelData != NULL)
 350         {
 351                 ChannelData->RemoteNumber = ConnectionResponse.SourceChannel;
 352                 ChannelData->State        = (ConnectionResponse.Result == BT_CONNECTION_SUCCESSFUL) ?
 353                                              Channel_Config_WaitConfig : Channel_Closed;
 354         }
 355 }
 356
 357
 358 static inline void Bluetooth_Signal_ConfigurationReq(BT_ACL_Header_t*        ACLPacketHeader,
 359                                                      BT_DataPacket_Header_t* DataHeader,
 360                                                      BT_Signal_Header_t*     SignalCommandHeader)
 361 {
 362         BT_Signal_ConfigurationReq_t ConfigurationRequest;
 363         uint8_t OptionsLen;
 364
 365         Pipe_Read_Stream_LE(&ConfigurationRequest, sizeof(ConfigurationRequest));
 366         OptionsLen = (DataHeader->PayloadLength - sizeof(*SignalCommandHeader));
 367
 368         Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConfigurationRequest.DestinationChannel, false);
 369
 370         while (OptionsLen)
 371         {
 372                 BT_Config_Option_Header_t OptionHeader;
 373
 374                 Pipe_Read_Stream_LE(&OptionHeader, sizeof(OptionHeader));
 375
 376                 if ((OptionHeader.Type == BT_CONFIG_OPTION_MTU) && (ChannelData != NULL))
 377                   Pipe_Read_Stream_LE(&ChannelData->RemoteMTU, sizeof(ChannelData->RemoteMTU));
 378                 else
 379                   Pipe_Discard_Stream(OptionHeader.Length);
 380
 381                 OptionsLen -= (sizeof(OptionHeader) + OptionHeader.Length);
 382         }
 383
 384         Pipe_ClearIN();
 385         Pipe_Freeze();
 386
 387         BT_ACL_DEBUG(1, "<< L2CAP Configuration Request", NULL);
 388         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConfigurationRequest.DestinationChannel);
 389         BT_ACL_DEBUG(2, "-- Options Len: 0x%04X", (DataHeader->PayloadLength - sizeof(*SignalCommandHeader)));
 390         BT_ACL_DEBUG(2, "-- Remote MTU: 0x%04X", ChannelData->RemoteMTU);
 391
 392         struct
 393         {
 394                 BT_Signal_Header_t            SignalCommandHeader;
 395                 BT_Signal_ConfigurationResp_t ConfigurationResponse;
 396         } ResponsePacket;
 397
 398         ResponsePacket.SignalCommandHeader.Code              = BT_SIGNAL_CONFIGURATION_RESPONSE;
 399         ResponsePacket.SignalCommandHeader.Identifier        = SignalCommandHeader->Identifier;
 400         ResponsePacket.SignalCommandHeader.Length            = sizeof(ResponsePacket.ConfigurationResponse);
 401         ResponsePacket.ConfigurationResponse.SourceChannel   = ChannelData->RemoteNumber;
 402         ResponsePacket.ConfigurationResponse.Flags           = 0x00;
 403         ResponsePacket.ConfigurationResponse.Result          = (ChannelData != NULL) ? BT_CONFIGURATION_SUCCESSFUL : BT_CONFIGURATION_REJECTED;
 404
 405         Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
 406
 407         if (ChannelData != NULL)
 408         {
 409                 switch (ChannelData->State)
 410                 {
 411                         case Channel_Config_WaitConfig:
 412                                 ChannelData->State = Channel_Config_WaitSendConfig;
 413                                 break;
 414                         case Channel_Config_WaitReqResp:
 415                                 ChannelData->State = Channel_Config_WaitResp;
 416                                 break;
 417                         case Channel_Config_WaitReq:
 418                                 ChannelData->State = Channel_Open;
 419                                 break;
 420                 }
 421         }
 422
 423         BT_ACL_DEBUG(1, ">> L2CAP Configuration Response", NULL);
 424         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.ConfigurationResponse.SourceChannel);
 425         BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.ConfigurationResponse.Result);
 426 }
 427
 428 static inline void Bluetooth_Signal_ConfigurationResp(BT_ACL_Header_t*        ACLPacketHeader,
 429                                                       BT_DataPacket_Header_t* DataHeader,
 430                                                       BT_Signal_Header_t*     SignalCommandHeader)
 431 {
 432         BT_Signal_ConfigurationResp_t ConfigurationResponse;
 433
 434         Pipe_Read_Stream_LE(&ConfigurationResponse, sizeof(ConfigurationResponse));
 435
 436         Pipe_ClearIN();
 437         Pipe_Freeze();
 438
 439         BT_ACL_DEBUG(1, "<< L2CAP Configuration Response", NULL);
 440         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConfigurationResponse.SourceChannel);
 441         BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConfigurationResponse.Result);
 442
 443         if (ConfigurationResponse.Result == BT_CONFIGURATION_SUCCESSFUL)
 444         {
 445                 Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConfigurationResponse.SourceChannel, true);
 446
 447                 if (ChannelData != NULL)
 448                 {
 449                         switch (ChannelData->State)
 450                         {
 451                                 case Channel_Config_WaitReqResp:
 452                                         ChannelData->State = Channel_Config_WaitReq;
 453                                         break;
 454                                 case Channel_Config_WaitResp:
 455                                         ChannelData->State = Channel_Open;
 456                                         break;
 457                         }
 458                 }
 459         }
 460 }
 461
 462 static inline void Bluetooth_Signal_DisconnectionReq(BT_ACL_Header_t*        ACLPacketHeader,
 463                                                      BT_DataPacket_Header_t* DataHeader,
 464                                                      BT_Signal_Header_t*     SignalCommandHeader)
 465 {
 466         BT_Signal_DisconnectionReq_t DisconnectionRequest;
 467
 468         Pipe_Read_Stream_LE(&DisconnectionRequest, sizeof(DisconnectionRequest));
 469
 470         BT_ACL_DEBUG(1, "<< L2CAP Disconnection Request", NULL);
 471         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DisconnectionRequest.DestinationChannel);
 472         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", DisconnectionRequest.SourceChannel);
 473
 474         Pipe_ClearIN();
 475         Pipe_Freeze();
 476
 477         Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(DisconnectionRequest.SourceChannel, true);
 478
 479         struct
 480         {
 481                 BT_Signal_Header_t            SignalCommandHeader;
 482                 BT_Signal_DisconnectionResp_t DisconnectionResponse;
 483         } ResponsePacket;
 484
 485         ResponsePacket.SignalCommandHeader.Code                 = BT_SIGNAL_DISCONNECTION_RESPONSE;
 486         ResponsePacket.SignalCommandHeader.Identifier           = SignalCommandHeader->Identifier;
 487         ResponsePacket.SignalCommandHeader.Length               = sizeof(ResponsePacket.DisconnectionResponse);
 488         ResponsePacket.DisconnectionResponse.DestinationChannel = ChannelData->RemoteNumber;
 489         ResponsePacket.DisconnectionResponse.SourceChannel      = ChannelData->LocalNumber;
 490
 491         Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
 492
 493         if (ChannelData != NULL)
 494           ChannelData->State = Channel_Closed;
 495
 496         BT_ACL_DEBUG(1, ">> L2CAP Disconnection Response", NULL);
 497         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ResponsePacket.DisconnectionResponse.SourceChannel);
 498         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ResponsePacket.DisconnectionResponse.DestinationChannel);
 499 }
 500
 501 static inline void Bluetooth_Signal_DisconnectionResp(BT_ACL_Header_t*        ACLPacketHeader,
 502                                                       BT_DataPacket_Header_t* DataHeader,
 503                                                       BT_Signal_Header_t*     SignalCommandHeader)
 504 {
 505         BT_Signal_DisconnectionResp_t DisconnectionResponse;
 506
 507         Pipe_Read_Stream_LE(&DisconnectionResponse, sizeof(DisconnectionResponse));
 508
 509         BT_ACL_DEBUG(1, "<< L2CAP Disconnection Response", NULL);
 510         BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", DisconnectionResponse.DestinationChannel);
 511         BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", DisconnectionResponse.SourceChannel);
 512
 513         Pipe_ClearIN();
 514         Pipe_Freeze();
 515
 516         Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(DisconnectionResponse.SourceChannel, true);
 517
 518         if (ChannelData->State == Channel_WaitDisconnect)
 519           ChannelData->State = Channel_Closed;
 520 }
 521
 522 static inline void Bluetooth_Signal_EchoReq(BT_ACL_Header_t* ACLPacketHeader,
 523                                             BT_DataPacket_Header_t* DataHeader,
 524                                             BT_Signal_Header_t* SignalCommandHeader)
 525 {
 526         BT_ACL_DEBUG(1, "<< L2CAP Echo Request", NULL);
 527
 528         Pipe_ClearIN();
 529         Pipe_Freeze();
 530
 531         struct
 532         {
 533                 BT_Signal_Header_t SignalCommandHeader;
 534         } ResponsePacket;
 535
 536         ResponsePacket.SignalCommandHeader.Code                 = BT_SIGNAL_ECHO_RESPONSE;
 537         ResponsePacket.SignalCommandHeader.Identifier           = SignalCommandHeader->Identifier;
 538         ResponsePacket.SignalCommandHeader.Length               = 0;
 539
 540         Bluetooth_SendPacket(&ResponsePacket, sizeof(ResponsePacket), NULL);
 541
 542         BT_ACL_DEBUG(1, ">> L2CAP Echo Response", NULL);
 543 }
 544
 545 static inline void Bluetooth_Signal_InformationReq(BT_ACL_Header_t*        ACLPacketHeader,
 546                                                    BT_DataPacket_Header_t* DataHeader,
 547                                                    BT_Signal_Header_t*     SignalCommandHeader)
 548 {
 549         BT_Signal_InformationReq_t InformationRequest;
 550
 551         Pipe_Read_Stream_LE(&InformationRequest, sizeof(InformationRequest));
 552
 553         BT_ACL_DEBUG(1, "<< L2CAP Information Request", NULL);
 554         BT_ACL_DEBUG(2, "-- Info Type: 0x%04X", InformationRequest.InfoType);
 555
 556         Pipe_ClearIN();
 557         Pipe_Freeze();
 558
 559         struct
 560         {
 561                 BT_Signal_Header_t SignalCommandHeader;
 562                 BT_Signal_InformationResp_t InformationResponse;
 563
 564                 uint8_t Data[4];
 565         } ResponsePacket;
 566
 567         uint8_t DataLen = 0;
 568
 569         switch (InformationRequest.InfoType)
 570         {
 571                 case BT_INFOREQ_MTU:
 572                         ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;
 573                         DataLen = 2;
 574
 575                         *((uint16_t*)&ResponsePacket.Data) = MAXIMUM_CHANNEL_MTU;
 576                         break;
 577                 case BT_INFOREQ_EXTENDEDFEATURES:
 578                         ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;
 579                         DataLen = 4;
 580
 581                         *((uint32_t*)&ResponsePacket.Data) = 0;
 582                         break;
 583                 default:
 584                         ResponsePacket.InformationResponse.Result = BT_INFORMATION_NOTSUPPORTED;
 585                         DataLen = 0;
 586                         break;
 587         }
 588
 589         ResponsePacket.SignalCommandHeader.Code                 = BT_SIGNAL_INFORMATION_RESPONSE;
 590         ResponsePacket.SignalCommandHeader.Identifier           = SignalCommandHeader->Identifier;
 591         ResponsePacket.SignalCommandHeader.Length               = sizeof(ResponsePacket.InformationResponse) + DataLen;
 592
 593         Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket) - sizeof(ResponsePacket.Data) + DataLen), NULL);
 594
 595         BT_ACL_DEBUG(1, ">> L2CAP Information Response", NULL);
 596         BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.InformationResponse.Result);
 597 }