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                                 switch (HCIEventHeader.EventCode)
  90                                 {
  91                                         case EVENT_COMMAND_COMPLETE:
  92                                                 Bluetooth_HCIProcessingState = Bluetooth_HCINextState;
  93                                                 break;
  94                                         case EVENT_COMMAND_STATUS:
  95                                                 /* If the execution of a command failed, reset the stack */
  96                                                 if (((Bluetooth_HCIEvent_CommandStatus_t*)&EventParams)->Status)
  97                                                   Bluetooth_HCIProcessingState = Bluetooth_Init;
  98                                                 break;
  99                                         case EVENT_CONNECTION_REQUEST:
 100                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 101                                                 memcpy(Bluetooth_TempDeviceAddress,
 102                                                        &((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->RemoteAddress,
 103                                                        sizeof(Bluetooth_TempDeviceAddress));
 104
 105                                                 bool IsACLConnection = (((Bluetooth_HCIEvent_ConnectionRequest_t*)&EventParams)->LinkType == 0x01);
 106
 107                                                 /* Only accept the connection if it is a ACL (data) connection, a device is not already connected
 108                                                    and the user application has indicated that the connection should be allowed */
 109                                                 Bluetooth_HCIProcessingState = (Bluetooth_Connection.IsConnected || !(IsACLConnection) ||
 110                                                                                                             !(Bluetooth_ConnectionRequest(Bluetooth_TempDeviceAddress))) ?
 111                                                                                                            Bluetooth_Conn_RejectConnection : Bluetooth_Conn_AcceptConnection;
 112                                                 break;
 113                                         case EVENT_PIN_CODE_REQUEST:
 114                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 115                                                 memcpy(Bluetooth_TempDeviceAddress,
 116                                                        &((Bluetooth_HCIEvent_PinCodeRequest_t*)&EventParams)->RemoteAddress,
 117                                                        sizeof(Bluetooth_TempDeviceAddress));
 118
 119                                                 Bluetooth_HCIProcessingState = Bluetooth_Conn_SendPINCode;
 120                                                 break;
 121                                         case EVENT_CONNECTION_COMPLETE:
 122                                                 /* Need to store the remote device's BT address in a temporary buffer for later use */
 123                                                 memcpy(Bluetooth_Connection.RemoteAddress,
 124                                                        &((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->RemoteAddress,
 125                                                        sizeof(Bluetooth_TempDeviceAddress));
 126
 127                                                 /* Store the created connection handle and indicate that the connection has been established */
 128                                                 Bluetooth_Connection.ConnectionHandle = ((Bluetooth_HCIEvent_ConnectionComplete_t*)&EventParams)->ConnectionHandle;
 129                                                 Bluetooth_Connection.IsConnected      = true;
 130
 131                                                 Bluetooth_ConnectionComplete();
 132                                                 break;
 133                                         case EVENT_DISCONNECTION_COMPLETE:
 134                                                 /* Device disconnected, indicate connection information no longer valid */
 135                                                 Bluetooth_Connection.IsConnected = false;
 136
 137                                                 Bluetooth_DisconnectionComplete();
 138
 139                                                 Bluetooth_HCIProcessingState = Bluetooth_Init;
 140                                                 break;
 141                                 }
 142                         }
 143
 144                         Pipe_Freeze();
 145
 146                         break;
 147                 case Bluetooth_Init:
 148                         /* Reset the connection information structure to destroy any previous connection state */
 149                         memset(&Bluetooth_Connection, 0x00, sizeof(Bluetooth_Connection));
 150
 151                         Bluetooth_HCIProcessingState = Bluetooth_Init_Reset;
 152                         break;
 153                 case Bluetooth_Init_Reset:
 154                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 155                         {
 156                                 OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_RESET},
 157                                 ParameterLength: 0,
 158                         };
 159
 160                         /* Send the command to reset the bluetooth dongle controller */
 161                         Bluetooth_SendHCICommand(NULL, 0);
 162
 163                         Bluetooth_HCINextState       = Bluetooth_Init_SetLocalName;
 164                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 165                         break;
 166                 case Bluetooth_Init_SetLocalName:
 167                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 168                                 {
 169                                         OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_LOCAL_NAME},
 170                                         ParameterLength: 248,
 171                                 };
 172
 173                         /* Send the command to set the bluetooth dongle's name for other devices to see */
 174                         Bluetooth_SendHCICommand(Bluetooth_DeviceConfiguration.Name, strlen(Bluetooth_DeviceConfiguration.Name));
 175
 176                         Bluetooth_HCINextState       = Bluetooth_Init_SetDeviceClass;
 177                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 178                         break;
 179                 case Bluetooth_Init_SetDeviceClass:
 180                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 181                                 {
 182                                         OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_CLASS_OF_DEVICE},
 183                                         ParameterLength: 3,
 184                                 };
 185
 186                         /* Send the command to set the class of the device for other devices to see */
 187                         Bluetooth_SendHCICommand(&Bluetooth_DeviceConfiguration.Class, 3);
 188
 189                         Bluetooth_HCINextState       = Bluetooth_Init_WriteScanEnable;
 190                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 191                         break;
 192                 case Bluetooth_Init_WriteScanEnable:
 193                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 194                         {
 195                                 OpCode: {OGF: OGF_CTRLR_BASEBAND, OCF: OCF_CTRLR_BASEBAND_WRITE_SCAN_ENABLE},
 196                                 ParameterLength: 1,
 197                         };
 198
 199                         uint8_t Interval = BT_SCANMODE_InquiryAndPageScans;
 200
 201                         /* Send the command to set the remote device scanning mode */
 202                         Bluetooth_SendHCICommand(&Interval, 1);
 203
 204                         Bluetooth_HCINextState       = Bluetooth_ProcessEvents;
 205                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 206                         break;
 207                 case Bluetooth_Conn_AcceptConnection:
 208                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 209                                 {
 210                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_ACCEPT_CONNECTION_REQUEST},
 211                                         ParameterLength: sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t),
 212                                 };
 213
 214                         /* Copy over the temporary BT device address saved from the Connection Request event, indicate slave
 215                            connection role */
 216                         Bluetooth_HCICommand_AcceptConnectionRequest_t AcceptConnectionParams;
 217                         memcpy(AcceptConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress,
 218                                sizeof(AcceptConnectionParams.RemoteAddress));
 219                         AcceptConnectionParams.SlaveRole = true;
 220
 221                         /* Send the command to accept the remote connection request */
 222                         Bluetooth_SendHCICommand(&AcceptConnectionParams, sizeof(Bluetooth_HCICommand_AcceptConnectionRequest_t));
 223
 224                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 225                         break;
 226                 case Bluetooth_Conn_RejectConnection:
 227                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 228                                 {
 229                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_REJECT_CONNECTION_REQUEST},
 230                                         ParameterLength: sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t),
 231                                 };
 232
 233                         /* Copy over the temporary BT device address saved from the Connection Request event, indicate failure
 234                            to accept the connection due to limited device resources or incorrect device address */
 235                         Bluetooth_HCICommand_RejectConnectionRequest_t RejectConnectionParams;
 236                         memcpy(RejectConnectionParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(RejectConnectionParams.RemoteAddress));
 237                         RejectConnectionParams.Reason = Bluetooth_Connection.IsConnected ? ERROR_LIMITED_RESOURCES : ERROR_UNACCEPTABLE_BDADDR;
 238
 239                         /* Send the command to reject the remote connection request */
 240                         Bluetooth_SendHCICommand(&RejectConnectionParams, sizeof(Bluetooth_HCICommand_RejectConnectionRequest_t));
 241
 242                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 243                         break;
 244                 case Bluetooth_Conn_SendPINCode:
 245                         HCICommandHeader = (Bluetooth_HCICommand_Header_t)
 246                                 {
 247                                         OpCode: {OGF: OGF_LINK_CONTROL, OCF: OCF_LINK_CONTROL_PIN_CODE_REQUEST_REPLY},
 248                                         ParameterLength: sizeof(Bluetooth_HCICommand_PinCodeResponse_t),
 249                                 };
 250
 251                         /* Copy over the temporary BT device address saved from the PIN Code Request event, copy over the
 252                            local PIN authentication code to the response */
 253                         Bluetooth_HCICommand_PinCodeResponse_t PINCodeRequestParams;
 254                         memcpy(PINCodeRequestParams.RemoteAddress, Bluetooth_TempDeviceAddress, sizeof(PINCodeRequestParams.RemoteAddress));
 255                         PINCodeRequestParams.PINCodeLength = strlen(Bluetooth_DeviceConfiguration.PINCode);
 256                         memcpy(PINCodeRequestParams.PINCode, Bluetooth_DeviceConfiguration.PINCode, sizeof(PINCodeRequestParams.PINCode));
 257
 258                         /* Send the command to transmit the device's local PIN number for authentication */
 259                         Bluetooth_SendHCICommand(&PINCodeRequestParams, sizeof(Bluetooth_HCICommand_PinCodeResponse_t));
 260
 261                         Bluetooth_HCIProcessingState = Bluetooth_ProcessEvents;
 262                         break;
 263         }
 264 }