Demos/Host/Incomplete/BluetoothHost/Lib/BluetoothHCICommands.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 #include "BluetoothHCICommands.h"
  32
  33 static Bluetooth_HCICommand_Header_t HCICommandHeader;
  34
  35        uint8_t                       Bluetooth_HCIProcessingState;
  36 static uint8_t                       Bluetooth_HCINextState;
  37 static uint8_t                       Bluetooth_TempDeviceAddress[6];
  38
  39 static uint8_t Bluetooth_SendHCICommand(void* Parameters, uint16_t ParameterLength)
  40 {
  41         /* Need to reserve the amount of bytes given in the header for the complete payload */
  42         uint8_t CommandBuffer[sizeof(HCICommandHeader) + HCICommandHeader.ParameterLength];
  43
  44         USB_ControlRequest = (USB_Request_Header_t)
  45                 {
  46                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_DEVICE),
  47                         .bRequest      = 0,
  48                         .wValue        = 0,
  49                         .wIndex        = 0,
  50                         .wLength       = sizeof(CommandBuffer)
  51                 };
  52
  53         /* Copy over the HCI command header to the allocated buffer */
  54         memcpy(CommandBuffer, &HCICommandHeader, sizeof(HCICommandHeader));
  55
  56         /* Zero out the parameter section of the response to ensure that any padding bytes do not expose private RAM contents */
  57         memset(&CommandBuffer[sizeof(HCICommandHeader)], 0x00, HCICommandHeader.ParameterLength);
  58
  59         /* Copy over the command parameters (if any) to the command buffer - note, the number of actual source parameter bytes
  60            may differ to those in the header; any difference in length is filled with 0x00 padding bytes */
  61         memcpy(&CommandBuffer[sizeof(HCICommandHeader)], Parameters, ParameterLength);
  62
  63         Pipe_SelectPipe(PIPE_CONTROLPIPE);
  64         return USB_Host_SendControlRequest(CommandBuffer);
  65 }
  66
  67 void Bluetooth_ProcessHCICommands(void)
  68 {
  69         switch (Bluetooth_HCIProcessingState)
  70         {
  71                 case Bluetooth_ProcessEvents:
  72                         Pipe_SelectPipe(BLUETOOTH_EVENTS_PIPE);
  73                         Pipe_Unfreeze();
  74
  75                         if (Pipe_IsReadWriteAllowed())
  76                         {
  77                                 Bluetooth_HCIEvent_Header_t HCIEventHeader;
  78
  79                                 /* Read in the event header to fetch the event code and payload length */
  80                                 Pipe_Read_Stream_LE(&HCIEventHeader, sizeof(HCIEventHeader));
  81
  82                                 /* Create a temporary buffer for the event parameters */
  83                                 uint8_t EventParams[HCIEventHeader.ParameterLength];
  84
  85                                 /* Read in the event parameters into the temporary buffer */
  86                                 Pipe_Read_Stream_LE(&EventParams, HCIEventHeader.ParameterLength);
  87                                 Pipe_ClearIN();
  88
  89                                 BT_HCI_DEBUG("Event Code: 0x%02X", HCIEventHeader.EventCode);
  90
  91                                 switch (HCIEventHeader.EventCode)
  92                                 {
  93                                         case EVENT_COMMAND_COMPLETE:
  94                                                 Bluetooth_HCIProcessingState = Bluetooth_HCINextState;
  95
  96                                                 BT_HCI_DEBUG(">> Command Complete (Opcode 0x%04x)",
  97                                                          ((Bluetooth_HCIEvent_CommandComplete_t*)&EventParams)->Opcode);
  98                                                 break;
  99                                         case EVENT_COMMAND_STATUS:
 100                                                 /* If the execution of a command failed, reset the stack */
 101                                                 if (((Bluetooth_HCIEvent_CommandStatus_t*)&EventParams)->Status)
 102                                                   Bluetooth_HCIProcessingState = Bluetooth_Init;
 103
 104                                                 BT_HCI_DEBUG(">> Command Status: 0x%02X",
 105                                                          ((Bluetooth_HCIEvent_CommandStatus_t*)&EventParams)->Status);
 106                                                 break;
 107                                         case EVENT_CONNECTION_REQUEST:
 108                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 109                                                 memcpy(Bluetooth_TempDeviceAddress,
 110                                                        &((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->RemoteAddress,
 111                                                        sizeof(Bluetooth_TempDeviceAddress));
 112
 113                                                 bool IsACLConnection = (((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->LinkType == 0x01);
 114
 115                                                 /* Only accept the connection if it is a ACL (data) connection, a device is not already connected
 116                                                    and the user application has indicated that the connection should be allowed */
 117                                                 Bluetooth_HCIProcessingState = (Bluetooth_Connection.IsConnected || !(IsACLConnection) ||
 118                                                                                                             !(CALLBACK_Bluetooth_ConnectionRequest(Bluetooth_TempDeviceAddress))) ?
 119                                                                                                            Bluetooth_Conn_RejectConnection : Bluetooth_Conn_AcceptConnection;
 120
 121                                                 BT_HCI_DEBUG(">> Connection Request from Device %02X:%02X:%02X:%02X:%02X:%02X",
 122                                                                  Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
 123                                                                  Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
 124                                                 break;
 125                                         case EVENT_PIN_CODE_REQUEST:
 126                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 127                                                 memcpy(Bluetooth_TempDeviceAddress,
 128                                                        &((Bluetooth_HCIEvent_PinCodeRequest_t*)&EventParams)->RemoteAddress,
 129                                                        sizeof(Bluetooth_TempDeviceAddress));
 130
 131                                                 Bluetooth_HCIProcessingState = Bluetooth_Conn_SendPINCode;
 132
 133                                                 BT_HCI_DEBUG(">> PIN Request from Device %02X:%02X:%02X:%02X:%02X:%02X",
 134                                                                  Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
 135                                                                  Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
 136                                                 break;
 137                                         case EVENT_CONNECTION_COMPLETE:
 138                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 139                                                 memcpy(Bluetooth_Connection.RemoteAddress,
 140                                                        &((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->RemoteAddress,
 141                                                        sizeof(Bluetooth_TempDeviceAddress));
 142
 143                                                 /* Store the created connection handle and indicate that the connection has been established */
 144                                                 Bluetooth_Connection.ConnectionHandle = ((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->ConnectionHandle;
 145                                                 Bluetooth_Connection.IsConnected      = true;
 146
 147                                                 BT_HCI_DEBUG(">> Connection Complete to Device %02X:%02X:%02X:%02X:%02X:%02X, Handle 0x%04x",
 148                                                                  Bluetooth_Connection.RemoteAddress[5], Bluetooth_Connection.RemoteAddress[4],
 149                                                                  Bluetooth_Connection.RemoteAddress[3], Bluetooth_Connection.RemoteAddress[2],
 150                                                                  Bluetooth_Connection.RemoteAddress[1], Bluetooth_Connection.RemoteAddress[0],
 151                                                                  Bluetooth_Connection.ConnectionHandle);
 152                                                 break;
 153                                         case EVENT_DISCONNECTION_COMPLETE:
 154                                                 BT_HCI_DEBUG(">> Disconnection Complete", NULL);
 155
 156                                                 /* Device disconnected, indicate connection information no longer valid */
 157                                                 Bluetooth_Connection.IsConnected = false;
 158
 159                                                 Bluetooth_HCIProcessingState = Bluetooth_Init;
 160                                                 break;
 161                                 }
 162                         }
 163
 164                         Pipe_Freeze();
 165
 166                         break;
 167                 case Bluetooth_Init:
 168                         /* Reset the connection information structure to destroy any previous connection state */
 169                         memset(&Bluetooth_Connection, 0x00, sizeof(Bluetooth_Connection));
 170
 171                         Bluetooth_HCIProcessingState = Bluetooth_Init_Reset;
 172                         break;
 173                 case Bluetooth_Init_Reset:
 174                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 175                         {
 176                                 OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_RESET},
 177                                 ParameterLength: 0,
 178                         };
 179
 180                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_Reset", NULL);
 181
 182                         /* Send the command to reset the bluetooth dongle controller */
 183                         Bluetooth_SendHCICommand(NULL, 0);
 184
 185                         Bluetooth_HCINextState       = Bluetooth_Init_SetLocalName;
 186                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 187                         break;
 188                 case Bluetooth_Init_SetLocalName:
 189                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 190                                 {
 191                                         OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_LOCAL_NAME},
 192                                         ParameterLength: 248,
 193                                 };
 194
 195                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_SetLocalName", NULL);
 196                         BT_HCI_DEBUG("-- Name: %s", Bluetooth_DeviceConfiguration.Name);
 197
 198                         /* Send the command to set the bluetooth dongle's name for other devices to see */
 199                         Bluetooth_SendHCICommand(Bluetooth_DeviceConfiguration.Name, strlen(Bluetooth_DeviceConfiguration.Name));
 200
 201                         Bluetooth_HCINextState       = Bluetooth_Init_SetDeviceClass;
 202                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 203                         break;
 204                 case Bluetooth_Init_SetDeviceClass:
 205                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 206                                 {
 207                                         OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_CLASS_OF_DEVICE},
 208                                         ParameterLength: 3,
 209                                 };
 210
 211                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_SetDeviceClass", NULL);
 212
 213                         /* Send the command to set the class of the device for other devices to see */
 214                         Bluetooth_SendHCICommand(&Bluetooth_DeviceConfiguration.Class, 3);
 215
 216                         Bluetooth_HCINextState       = Bluetooth_Init_WriteScanEnable;
 217                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 218                         break;
 219                 case Bluetooth_Init_WriteScanEnable:
 220                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 221                         {
 222                                 OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_SCAN_ENABLE},
 223                                 ParameterLength: 1,
 224                         };
 225
 226                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_WriteScanEnable", NULL);
 227
 228                         uint8_t Interval = BT_SCANMODE_InquiryAndPageScans;
 229
 230                         /* Send the command to set the remote device scanning mode */
 231                         Bluetooth_SendHCICommand(&Interval, 1);
 232
 233                         Bluetooth_HCINextState       = Bluetooth_ProcessEvents;
 234                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 235                         break;
 236                 case Bluetooth_Conn_AcceptConnection:
 237                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 238                                 {
 239                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_ACCEPT_CONNECTION_REQUEST},
 240                                         ParameterLength: sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t),
 241                                 };
 242
 243                         BT_HCI_DEBUG("Enter State: Bluetooth_Conn_AcceptConnection", NULL);
 244
 245                         /* Copy over the temporary BT device address saved from the Connection Request event, indicate slave
 246                            connection role */
 247                         Bluetooth_HCICommand_AcceptConnectionRequest_t AcceptConnectionParams;
 248                         memcpy(AcceptConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress,
 249                                sizeof(AcceptConnectionParams.RemoteAddress));
 250                         AcceptConnectionParams.SlaveRole = true;
 251
 252                         /* Send the command to accept the remote connection request */
 253                         Bluetooth_SendHCICommand(&AcceptConnectionParams, sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t));
 254
 255                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 256                         break;
 257                 case Bluetooth_Conn_RejectConnection:
 258                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 259                                 {
 260                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_REJECT_CONNECTION_REQUEST},
 261                                         ParameterLength: sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t),
 262                                 };
 263
 264                         BT_HCI_DEBUG("Enter State: Bluetooth_Conn_RejectConnection", NULL);
 265
 266                         /* Copy over the temporary BT device address saved from the Connection Request event, indicate failure
 267                            to accept the connection due to limited device resources or incorrect device address */
 268                         Bluetooth_HCICommand_RejectConnectionRequest_t RejectConnectionParams;
 269                         memcpy(RejectConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(RejectConnectionParams.RemoteAddress));
 270                         RejectConnectionParams.Reason = Bluetooth_Connection.IsConnected ? ERROR_LIMITED_RESOURCES : ERROR_UNACCEPTABLE_BDADDR;
 271
 272                         /* Send the command to reject the remote connection request */
 273                         Bluetooth_SendHCICommand(&RejectConnectionParams, sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t));
 274
 275                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 276                         break;
 277                 case Bluetooth_Conn_SendPINCode:
 278                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 279                                 {
 280                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_PIN_CODE_REQUEST_REPLY},
 281                                         ParameterLength: sizeof(Bluetooth_HCICommand_PinCodeResponse_t),
 282                                 };
 283
 284                         BT_HCI_DEBUG("Enter State: Bluetooth_Conn_SendPINCode", NULL);
 285                         BT_HCI_DEBUG("-- PIN: %s", Bluetooth_DeviceConfiguration.PINCode);
 286
 287                         /* Copy over the temporary BT device address saved from the PIN Code Request event, copy over the
 288                            local PIN authentication code to the response */
 289                         Bluetooth_HCICommand_PinCodeResponse_t PINCodeRequestParams;
 290                         memcpy(PINCodeRequestParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(PINCodeRequestParams.RemoteAddress));
 291                         PINCodeRequestParams.PINCodeLength = strlen(Bluetooth_DeviceConfiguration.PINCode);
 292                         memcpy(PINCodeRequestParams.PINCode, Bluetooth_DeviceConfiguration.PINCode, sizeof(PINCodeRequestParams.PINCode));
 293
 294                         /* Send the command to transmit the device's local PIN number for authentication */
 295                         Bluetooth_SendHCICommand(&PINCodeRequestParams, sizeof(Bluetooth_HCICommand_PinCodeResponse_t));
 296
 297                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 298                         break;
 299         }
 300 }