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