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