1 /* 2 * hci.c 3 * 4 * Created by Matthias Ringwald on 4/29/09. 5 * 6 */ 7 8 #include <unistd.h> 9 #include <stdarg.h> 10 #include <string.h> 11 #include <stdio.h> 12 #include "hci.h" 13 14 // calculate combined ogf/ocf value 15 #define OPCODE(ogf, ocf) (ocf | ogf << 10) 16 #define OGF_LINK_CONTROL 0x01 17 #define OGF_CONTROLLER_BASEBAND 0x03 18 #define OGF_INFORMATIONAL_PARAMETERS 0x04 19 20 /** 21 * Link Control Commands 22 */ 23 hci_cmd_t hci_inquiry = { 24 OPCODE(OGF_LINK_CONTROL, 0x01), "311" 25 // LAP, Inquiry length, Num_responses 26 }; 27 hci_cmd_t hci_inquiry_cancel = { 28 OPCODE(OGF_LINK_CONTROL, 0x02), "" 29 // no params 30 }; 31 hci_cmd_t hci_create_connection = { 32 OPCODE(OGF_LINK_CONTROL, 0x05), "B21121" 33 // BD_ADDR, Packet_Type, Page_Scan_Repetition_Mode, Reserved, Clock_Offset, Allow_Role_Switch 34 }; 35 36 hci_cmd_t hci_accept_connection_request = { 37 OPCODE(OGF_LINK_CONTROL, 0x09), "B1" 38 // BD_ADDR, Role: become master, stay slave 39 }; 40 hci_cmd_t hci_link_key_request_negative_reply = { 41 OPCODE(OGF_LINK_CONTROL, 0x0c), "B" 42 }; 43 hci_cmd_t hci_pin_code_request_reply = { 44 OPCODE(OGF_LINK_CONTROL, 0x0d), "B1P" 45 // BD_ADDR, pin length, PIN: c-string 46 }; 47 hci_cmd_t hci_remote_name_request = { 48 OPCODE(OGF_LINK_CONTROL, 0x19), "B112" 49 // BD_ADDR, Page_Scan_Repetition_Mode, Reserved, Clock_Offset 50 }; 51 hci_cmd_t hci_remote_name_request_cancel = { 52 OPCODE(OGF_LINK_CONTROL, 0x1A), "B" 53 // BD_ADDR 54 }; 55 56 /** 57 * Controller & Baseband Commands 58 */ 59 hci_cmd_t hci_reset = { 60 OPCODE(OGF_CONTROLLER_BASEBAND, 0x03), "" 61 // no params 62 }; 63 hci_cmd_t hci_delete_stored_link_key = { 64 OPCODE(OGF_CONTROLLER_BASEBAND, 0x12), "B1" 65 // BD_ADDR, Delete_All_Flag 66 }; 67 hci_cmd_t hci_write_page_timeout = { 68 OPCODE(OGF_CONTROLLER_BASEBAND, 0x18), "2" 69 // Page_Timeout * 0.625 ms 70 }; 71 hci_cmd_t hci_write_scan_enable = { 72 OPCODE(OGF_CONTROLLER_BASEBAND, 0x1A), "1" 73 // Scan_enable: no, inq, page, inq+page 74 }; 75 76 hci_cmd_t hci_write_authentication_enable = { 77 OPCODE(OGF_CONTROLLER_BASEBAND, 0x20), "1" 78 // Authentication_Enable 79 }; 80 hci_cmd_t hci_host_buffer_size = { 81 OPCODE(OGF_CONTROLLER_BASEBAND, 0x33), "2122" 82 // Host_ACL_Data_Packet_Length:, Host_Synchronous_Data_Packet_Length:, Host_Total_Num_ACL_Data_Packets:, Host_Total_Num_Synchronous_Data_Packets: 83 }; 84 85 hci_cmd_t hci_read_bd_addr = { 86 OPCODE(OGF_INFORMATIONAL_PARAMETERS, 0x09), "" 87 // no params 88 }; 89 90 91 // the stack is here 92 static hci_stack_t hci_stack; 93 94 95 void bt_store_16(uint8_t *buffer, uint16_t pos, uint16_t value){ 96 buffer[pos++] = value; 97 buffer[pos++] = value >> 8; 98 } 99 100 void bt_store_32(uint8_t *buffer, uint16_t pos, uint32_t value){ 101 buffer[pos++] = value; 102 buffer[pos++] = value >> 8; 103 buffer[pos++] = value >> 16; 104 buffer[pos++] = value >> 24; 105 } 106 107 void bt_flip_addr(bd_addr_t dest, bd_addr_t src){ 108 dest[0] = src[5]; 109 dest[1] = src[4]; 110 dest[2] = src[3]; 111 dest[3] = src[2]; 112 dest[4] = src[1]; 113 dest[5] = src[0]; 114 } 115 116 void hexdump(void *data, int size){ 117 int i; 118 for (i=0; i<size;i++){ 119 printf("%02X ", ((uint8_t *)data)[i]); 120 } 121 printf("\n"); 122 } 123 124 /** 125 * Linked link list 126 */ 127 128 /** 129 * get link for given address 130 * 131 * @return connection OR NULL, if not found 132 */ 133 #if 0 134 static hci_connection_t *link_for_addr(bd_addr_t addr){ 135 return NULL; 136 } 137 #endif 138 139 /** 140 * Handler called by HCI transport 141 */ 142 static void dummy_handler(uint8_t *packet, int size){ 143 } 144 145 static void acl_handler(uint8_t *packet, int size){ 146 hci_stack.acl_packet_handler(packet, size); 147 148 // execute main loop 149 hci_run(); 150 } 151 152 static void event_handler(uint8_t *packet, int size){ 153 bd_addr_t addr; 154 155 // Get Num_HCI_Command_Packets 156 if (packet[0] == HCI_EVENT_COMMAND_COMPLETE || 157 packet[0] == HCI_EVENT_COMMAND_STATUS){ 158 hci_stack.num_cmd_packets = packet[2]; 159 } 160 161 // handle BT initialization 162 if (hci_stack.state == HCI_STATE_INITIALIZING){ 163 // handle H4 synchronization loss on restart 164 // if (hci_stack.substate == 1 && packet[0] == HCI_EVENT_HARDWARE_ERROR){ 165 // hci_stack.substate = 0; 166 // } 167 // handle normal init sequence 168 if (hci_stack.substate % 2){ 169 // odd: waiting for event 170 if (packet[0] == HCI_EVENT_COMMAND_COMPLETE){ 171 hci_stack.substate++; 172 } 173 } 174 } 175 176 // link key request 177 if (packet[0] == HCI_EVENT_LINK_KEY_REQUEST){ 178 bt_flip_addr(addr, &packet[2]); 179 hci_send_cmd(&hci_link_key_request_negative_reply, &addr); 180 return; 181 } 182 183 // pin code request 184 if (packet[0] == HCI_EVENT_PIN_CODE_REQUEST){ 185 bt_flip_addr(addr, &packet[2]); 186 hci_send_cmd(&hci_pin_code_request_reply, &addr, 4, "1234"); 187 } 188 189 hci_stack.event_packet_handler(packet, size); 190 191 // execute main loop 192 hci_run(); 193 } 194 195 /** Register L2CAP handlers */ 196 void hci_register_event_packet_handler(void (*handler)(uint8_t *packet, int size)){ 197 hci_stack.event_packet_handler = handler; 198 } 199 void hci_register_acl_packet_handler (void (*handler)(uint8_t *packet, int size)){ 200 hci_stack.acl_packet_handler = handler; 201 } 202 203 static int null_control_function(void *config){ 204 return 0; 205 } 206 static const char * null_control_name(void *config){ 207 return "Hardware unknown"; 208 } 209 210 static bt_control_t null_control = { 211 null_control_function, 212 null_control_function, 213 null_control_function, 214 null_control_name 215 }; 216 217 void hci_init(hci_transport_t *transport, void *config, bt_control_t *control){ 218 219 // reference to use transport layer implementation 220 hci_stack.hci_transport = transport; 221 222 // references to used control implementation 223 if (control) { 224 hci_stack.control = control; 225 } else { 226 hci_stack.control = &null_control; 227 } 228 229 // reference to used config 230 hci_stack.config = config; 231 232 // empty cmd buffer 233 hci_stack.hci_cmd_buffer = malloc(3+255); 234 235 // higher level handler 236 hci_stack.event_packet_handler = dummy_handler; 237 hci_stack.acl_packet_handler = dummy_handler; 238 239 // register packet handlers with transport 240 transport->register_event_packet_handler( event_handler); 241 transport->register_acl_packet_handler( acl_handler); 242 } 243 244 int hci_power_control(HCI_POWER_MODE power_mode){ 245 if (power_mode == HCI_POWER_ON) { 246 247 // set up state machine 248 hci_stack.num_cmd_packets = 1; // assume that one cmd can be sent 249 hci_stack.state = HCI_STATE_INITIALIZING; 250 hci_stack.substate = 0; 251 252 // power on 253 hci_stack.control->on(hci_stack.config); 254 255 // open low-level device 256 hci_stack.hci_transport->open(hci_stack.config); 257 258 } else if (power_mode == HCI_POWER_OFF){ 259 260 // close low-level device 261 hci_stack.hci_transport->close(hci_stack.config); 262 263 // power off 264 hci_stack.control->off(hci_stack.config); 265 } 266 267 // trigger next/first action 268 hci_run(); 269 270 return 0; 271 } 272 273 uint32_t hci_run(){ 274 uint8_t micro_packet; 275 switch (hci_stack.state){ 276 case HCI_STATE_INITIALIZING: 277 if (hci_stack.substate % 2) { 278 // odd: waiting for command completion 279 return 0; 280 } 281 if (hci_stack.num_cmd_packets == 0) { 282 // cannot send command yet 283 return 0; 284 } 285 switch (hci_stack.substate/2){ 286 case 0: 287 hci_send_cmd(&hci_reset); 288 break; 289 case 1: 290 hci_send_cmd(&hci_read_bd_addr); 291 break; 292 case 2: 293 // ca. 15 sec 294 hci_send_cmd(&hci_write_page_timeout, 0x6000); 295 break; 296 case 3: 297 hci_send_cmd(&hci_write_scan_enable, 3); 298 break; 299 case 4: 300 // done. 301 hci_stack.state = HCI_STATE_WORKING; 302 micro_packet = BTSTACK_EVENT_HCI_WORKING; 303 hci_stack.event_packet_handler(µ_packet, 1); 304 break; 305 default: 306 break; 307 } 308 hci_stack.substate++; 309 break; 310 default: 311 break; 312 } 313 314 // don't check for timetous yet 315 return 0; 316 } 317 318 319 int hci_send_acl_packet(uint8_t *packet, int size){ 320 return hci_stack.hci_transport->send_acl_packet(packet, size); 321 } 322 323 324 /** 325 * pre: numcmds >= 0 - it's allowed to send a command to the controller 326 */ 327 int hci_send_cmd(hci_cmd_t *cmd, ...){ 328 uint8_t * hci_cmd_buffer = hci_stack.hci_cmd_buffer; 329 hci_cmd_buffer[0] = cmd->opcode & 0xff; 330 hci_cmd_buffer[1] = cmd->opcode >> 8; 331 int pos = 3; 332 333 va_list argptr; 334 va_start(argptr, cmd); 335 const char *format = cmd->format; 336 uint16_t word; 337 uint32_t longword; 338 uint8_t * ptr; 339 while (*format) { 340 switch(*format) { 341 case '1': // 8 bit value 342 case '2': // 16 bit value 343 case 'H': // hci_handle 344 word = va_arg(argptr, int); // minimal va_arg is int: 2 bytes on 8+16 bit CPUs 345 hci_cmd_buffer[pos++] = word & 0xff; 346 if (*format == '2') { 347 hci_cmd_buffer[pos++] = word >> 8; 348 } else if (*format == 'H') { 349 // TODO 350 } 351 break; 352 case '3': 353 case '4': 354 longword = va_arg(argptr, uint32_t); 355 // longword = va_arg(argptr, int); 356 hci_cmd_buffer[pos++] = longword; 357 hci_cmd_buffer[pos++] = longword >> 8; 358 hci_cmd_buffer[pos++] = longword >> 16; 359 if (*format == '4'){ 360 hci_cmd_buffer[pos++] = longword >> 24; 361 } 362 break; 363 case 'B': // bt-addr 364 ptr = va_arg(argptr, uint8_t *); 365 hci_cmd_buffer[pos++] = ptr[5]; 366 hci_cmd_buffer[pos++] = ptr[4]; 367 hci_cmd_buffer[pos++] = ptr[3]; 368 hci_cmd_buffer[pos++] = ptr[2]; 369 hci_cmd_buffer[pos++] = ptr[1]; 370 hci_cmd_buffer[pos++] = ptr[0]; 371 break; 372 case 'P': // c string passed as pascal string with leading 1-byte len 373 ptr = va_arg(argptr, uint8_t *); 374 memcpy(&hci_cmd_buffer[pos], ptr, 16); 375 pos += 16; 376 break; 377 default: 378 break; 379 } 380 format++; 381 }; 382 va_end(argptr); 383 hci_cmd_buffer[2] = pos - 3; 384 // send packet 385 hci_stack.num_cmd_packets--; 386 return hci_stack.hci_transport->send_cmd_packet(hci_cmd_buffer, pos); 387 }