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