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                                                 /* Only accept the connection if it is a ACL (data) connection */
 114                                                 Bluetooth_HCIProcessingState = (Bluetooth_Connection.IsConnected ||
 115                                                                                (((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->LinkType != 0x01)) ?
 116                                                                                                            Bluetooth_Conn_RejectConnection : Bluetooth_Conn_AcceptConnection;
 117
 118                                                 BT_HCI_DEBUG(">> Connection Request from Device %02X:%02X:%02X:%02X:%02X:%02X",
 119                                                                  Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
 120                                                                  Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
 121                                                 break;
 122                                         case EVENT_PIN_CODE_REQUEST:
 123                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 124                                                 memcpy(Bluetooth_TempDeviceAddress,
 125                                                        &((Bluetooth_HCIEvent_PinCodeRequest_t*)&EventParams)->RemoteAddress,
 126                                                        sizeof(Bluetooth_TempDeviceAddress));
 127
 128                                                 Bluetooth_HCIProcessingState = Bluetooth_Conn_SendPINCode;
 129
 130                                                 BT_HCI_DEBUG(">> PIN Request from Device %02X:%02X:%02X:%02X:%02X:%02X",
 131                                                                  Bluetooth_TempDeviceAddress[5], Bluetooth_TempDeviceAddress[4], Bluetooth_TempDeviceAddress[3],
 132                                                                  Bluetooth_TempDeviceAddress[2], Bluetooth_TempDeviceAddress[1], Bluetooth_TempDeviceAddress[0]);
 133                                                 break;
 134                                         case EVENT_CONNECTION_COMPLETE:
 135                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 136                                                 memcpy(Bluetooth_Connection.RemoteAddress,
 137                                                        &((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->RemoteAddress,
 138                                                        sizeof(Bluetooth_TempDeviceAddress));
 139
 140                                                 /* Store the created connection handle and indicate that the connection has been established */
 141                                                 Bluetooth_Connection.ConnectionHandle = ((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->ConnectionHandle;
 142                                                 Bluetooth_Connection.IsConnected      = true;
 143
 144                                                 BT_HCI_DEBUG(">> Connection Complete to Device %02X:%02X:%02X:%02X:%02X:%02X, Handle 0x%04x",
 145                                                                  Bluetooth_Connection.RemoteAddress[5], Bluetooth_Connection.RemoteAddress[4],
 146                                                                  Bluetooth_Connection.RemoteAddress[3], Bluetooth_Connection.RemoteAddress[2],
 147                                                                  Bluetooth_Connection.RemoteAddress[1], Bluetooth_Connection.RemoteAddress[0],
 148                                                                  Bluetooth_Connection.ConnectionHandle);
 149                                                 break;
 150                                         case EVENT_DISCONNECTION_COMPLETE:
 151                                                 BT_HCI_DEBUG(">> Disconnection Complete", NULL);
 152
 153                                                 /* Device disconnected, indicate connection information no longer valid */
 154                                                 Bluetooth_Connection.IsConnected = false;
 155
 156                                                 Bluetooth_HCIProcessingState = Bluetooth_Init;
 157                                                 break;
 158                                 }
 159                         }
 160
 161                         Pipe_Freeze();
 162
 163                         break;
 164                 case Bluetooth_Init:
 165                         /* Reset the connection information structure to destroy any previous connection state */
 166                         memset(&Bluetooth_Connection, 0x00, sizeof(Bluetooth_Connection));
 167
 168                         Bluetooth_HCIProcessingState = Bluetooth_Init_Reset;
 169                         break;
 170                 case Bluetooth_Init_Reset:
 171                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 172                         {
 173                                 OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_RESET},
 174                                 ParameterLength: 0,
 175                         };
 176
 177                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_Reset", NULL);
 178
 179                         /* Send the command to reset the bluetooth dongle controller */
 180                         Bluetooth_SendHCICommand(NULL, 0);
 181
 182                         Bluetooth_HCINextState       = Bluetooth_Init_SetLocalName;
 183                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 184                         break;
 185                 case Bluetooth_Init_SetLocalName:
 186                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 187                                 {
 188                                         OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_LOCAL_NAME},
 189                                         ParameterLength: 248,
 190                                 };
 191
 192                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_SetLocalName", NULL);
 193                         BT_HCI_DEBUG("-- Name: %s", Bluetooth_DeviceConfiguration.Name);
 194
 195                         /* Send the command to set the bluetooth dongle's name for other devices to see */
 196                         Bluetooth_SendHCICommand(Bluetooth_DeviceConfiguration.Name, strlen(Bluetooth_DeviceConfiguration.Name));
 197
 198                         Bluetooth_HCINextState       = Bluetooth_Init_SetDeviceClass;
 199                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 200                         break;
 201                 case Bluetooth_Init_SetDeviceClass:
 202                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 203                                 {
 204                                         OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_CLASS_OF_DEVICE},
 205                                         ParameterLength: 3,
 206                                 };
 207
 208                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_SetDeviceClass", NULL);
 209
 210                         /* Send the command to set the class of the device for other devices to see */
 211                         Bluetooth_SendHCICommand(&Bluetooth_DeviceConfiguration.Class, 3);
 212
 213                         Bluetooth_HCINextState       = Bluetooth_Init_WriteScanEnable;
 214                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 215                         break;
 216                 case Bluetooth_Init_WriteScanEnable:
 217                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 218                         {
 219                                 OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_SCAN_ENABLE},
 220                                 ParameterLength: 1,
 221                         };
 222
 223                         BT_HCI_DEBUG("Enter State: Bluetooth_Init_WriteScanEnable", NULL);
 224
 225                         uint8_t Interval = BT_SCANMODE_InquiryAndPageScans;
 226
 227                         /* Send the command to set the remote device scanning mode */
 228                         Bluetooth_SendHCICommand(&Interval, 1);
 229
 230                         Bluetooth_HCINextState       = Bluetooth_ProcessEvents;
 231                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 232                         break;
 233                 case Bluetooth_Conn_AcceptConnection:
 234                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 235                                 {
 236                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_ACCEPT_CONNECTION_REQUEST},
 237                                         ParameterLength: sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t),
 238                                 };
 239
 240                         BT_HCI_DEBUG("Enter State: Bluetooth_Conn_AcceptConnection", NULL);
 241
 242                         /* Copy over the temporary BT device address saved from the Connection Request event, indicate slave
 243                            connection role */
 244                         Bluetooth_HCICommand_AcceptConnectionRequest_t AcceptConnectionParams;
 245                         memcpy(AcceptConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress,
 246                                sizeof(AcceptConnectionParams.RemoteAddress));
 247                         AcceptConnectionParams.SlaveRole = true;
 248
 249                         /* Send the command to accept the remote connection request */
 250                         Bluetooth_SendHCICommand(&AcceptConnectionParams, sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t));
 251
 252                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 253                         break;
 254                 case Bluetooth_Conn_RejectConnection:
 255                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 256                                 {
 257                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_REJECT_CONNECTION_REQUEST},
 258                                         ParameterLength: sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t),
 259                                 };
 260
 261                         BT_HCI_DEBUG("Enter State: Bluetooth_Conn_RejectConnection", NULL);
 262
 263                         /* Copy over the temporary BT device address saved from the Connection Request event, indicate failure
 264                            to accept the connection due to limited device resources */
 265                         Bluetooth_HCICommand_RejectConnectionRequest_t RejectConnectionParams;
 266                         memcpy(RejectConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(RejectConnectionParams.RemoteAddress));
 267                         RejectConnectionParams.Reason = ERROR_LIMITED_RESOURCES;
 268
 269                         /* Send the command to reject the remote connection request */
 270                         Bluetooth_SendHCICommand(&RejectConnectionParams, sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t));
 271
 272                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 273                         break;
 274                 case Bluetooth_Conn_SendPINCode:
 275                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 276                                 {
 277                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_PIN_CODE_REQUEST_REPLY},
 278                                         ParameterLength: sizeof(Bluetooth_HCICommand_PinCodeResponse_t),
 279                                 };
 280
 281                         BT_HCI_DEBUG("Enter State: Bluetooth_Conn_SendPINCode", NULL);
 282                         BT_HCI_DEBUG("-- PIN: %s", Bluetooth_DeviceConfiguration.PINCode);
 283
 284                         /* Copy over the temporary BT device address saved from the PIN Code Request event, copy over the
 285                            local PIN authentication code to the response */
 286                         Bluetooth_HCICommand_PinCodeResponse_t PINCodeRequestParams;
 287                         memcpy(PINCodeRequestParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(PINCodeRequestParams.RemoteAddress));
 288                         PINCodeRequestParams.PINCodeLength = strlen(Bluetooth_DeviceConfiguration.PINCode);
 289                         memcpy(PINCodeRequestParams.PINCode, Bluetooth_DeviceConfiguration.PINCode, sizeof(PINCodeRequestParams.PINCode));
 290
 291                         /* Send the command to transmit the device's local PIN number for authentication */
 292                         Bluetooth_SendHCICommand(&PINCodeRequestParams, sizeof(Bluetooth_HCICommand_PinCodeResponse_t));
 293
 294                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 295                         break;
 296         }
 297 }