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