src2/tiny_bt_hci_core.c

   1 /*
   2 *  C Implementation: testovaci
   3 *
   4 * Description:
   5 *
   6 *
   7 * Author: root <root@ubuntu>, (C) 2008
   8 *
   9 * Copyright: See COPYING file that comes with this distribution
  10 *
  11 */
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <sys/ioctl.h>
  15 #include <errno.h>
  16 #include <stdint.h>
  17 #include "tiny_bt_hci_core.h"
  18 #include "tiny_bt_hci_cmd.h"
  19 #include "bt_hw.h"
  20
  21 static expect_evt evt_array[MAX_CMD_STATE_REQUEST];
  22 static int evt_id;
  23 static int global_index;
  24 extern connection_hci connection;
  25 /******************************HCI callback functions*********************/
  26 /*when propriate event has occured and this event was registered in evt_array
  27 * these callback_hci..... are callled , they explore event's data field and call
  28 * propriate upper protocol(or application) callback and also deliver, parameters
  29 * which has occured with inbound event */
  30 static void callback_hci_all_commands(void *p_arg, void *p_recbuf)
  31 {
  32         evt_cmd_status *p_rp;
  33         p_rp = (void *) p_recbuf;
  34
  35         if (p_rp->status) {
  36                 perror("command status error\n");
  37                 tiny_bt_finish();
  38                 //return -1;
  39                 /*TODO call some app_callback and do something with error state
  40                 * I only write out the inbound opcode , if any problem has occured
  41                 * it is not solve here yet. */
  42                 exit(1); // !!!!!!!!!!!!!!!!
  43         }
  44
  45         printf("command status with opcode: %d\n",p_rp->opcode);
  46         //return 0;
  47 }
  48
  49 static void callback_hci_read_bd_addr(void *p_arg, void *p_recbuf)
  50 {
  51         read_bd_addr_data *p_data = p_arg;
  52         read_bd_addr_rp *p_rp;
  53
  54         p_rp = (void *) (p_recbuf + 3);
  55         memcpy(p_data->p_address, &p_rp->bdaddr, 6);
  56         p_data->callback_app_read_bd_addr(p_data->p_address);
  57         free(p_data);
  58 }
  59
  60 static void callback_hci_read_local_name(void *p_arg, void *p_recbuf)
  61 {
  62         read_local_name_data *p_data = p_arg;
  63         read_local_name_rp *p_rp;
  64
  65         p_rp = (void *) (p_recbuf + 3);
  66         memcpy(p_data->p_name, &p_rp->name, 248);
  67         p_data->callback_app_read_local_name(p_data->p_name);
  68         free(p_data);
  69 }
  70
  71 static void callback_hci_inquiry_RSSI(void *p_arg, void *p_recbuf)
  72 {
  73         inquiry_RSSI_data *p_data = p_arg;
  74         inquiry_info_with_rssi *p_rp;
  75
  76         p_rp = (void *) (p_recbuf + 1);
  77         memcpy(p_data->p_address, &p_rp->bdaddr, 6);
  78         p_data->callback_app_inquiry_RSSI(p_data->p_address);
  79         free(p_data);
  80 }
  81
  82 static void callback_hci_inquiry_comple(void *p_arg, void *p_recbuf)
  83 {
  84         inquiry_complete_data *p_data = p_arg;
  85         __u8 *p_byte;
  86
  87         p_byte = (void *) p_recbuf;
  88         if (*p_byte) {
  89                 perror("inquiry complete status error\n");
  90                 exit(-1); // !!!!!!!!
  91         }
  92
  93         p_data->callback_app_inquiry_complete();
  94         free(p_data);
  95 }
  96
  97 static void callback_hci_create_connection(void *p_arg, void *p_recbuf)
  98 {
  99         connection_complete_data *p_data = p_arg;
 100         evt_conn_complete *p_rp;
 101
 102         p_rp = (void *) (p_recbuf);
 103         memcpy(p_data->p_handle, &p_rp->handle, 2);
 104         //memcpy(p_data->p_address,&p_rp->bdaddr,6);
 105         p_data->callback_app_connection_complete(p_data->p_handle);
 106         free(p_data);
 107 }
 108
 109 static void callback_hci_connection_request(void *p_arg, void *p_recbuf)
 110 {
 111         connection_request_data *p_data = p_arg;
 112         evt_conn_request *p_rp;
 113
 114         p_rp = (void *) (p_recbuf);
 115         memcpy(p_data->p_address, &p_rp->bdaddr, 6);
 116         p_data->callback_app_connection_request(p_data->p_address);
 117         free(p_data);
 118 }
 119
 120 static void callback_hci_disconnect(void *p_arg, void *p_recbuf)
 121 {
 122         disconnect_data *p_data = p_arg;
 123         evt_disconn_complete *p_rp;
 124
 125         p_rp = (void *) (p_recbuf);
 126         p_data->callback_app_disconnect(&p_rp->handle, &p_rp->reason);
 127         free(p_data);
 128 }
 129
 130 /******************************array functions*********************/
 131 /*fcn add the request at the end of array or replace the oldest request*/
 132 void add_evt_toarray(expect_evt *p_evt)
 133 {
 134         int i;
 135         int sig = 0,index = 0;
 136         expect_evt the_oldest = evt_array[0];
 137
 138         for (i = 0; i < MAX_EVT_COUNT; i++) {/*todo use constatns will be better*/
 139                 if (evt_array[i].actual_status == 0 || evt_array[i].actual_status == 3) {
 140                         evt_array[i] = *p_evt;
 141                         sig=1;
 142                         global_index=i;
 143                         break;
 144                 }
 145                 /*the smallest id (oldest request) will stay here*/
 146                 if (evt_array[i].id < the_oldest.id) {
 147                         the_oldest = evt_array[i];
 148                         index=i;
 149
 150                 }
 151         }
 152         if (!sig) {
 153                 evt_array[index] = *p_evt;
 154                 global_index = index;
 155         }
 156 }
 157
 158 int look_up_inarray(__u8 evt_type, __u16 opcode)
 159 {
 160         int i;
 161         int index = -1, oldestid = 65535;
 162
 163         if (evt_array[global_index].evt_type == evt_type && evt_array[global_index].actual_status != DONE) {
 164                 if (opcode != 0) {
 165                         if(evt_array[global_index].req_opcode == opcode)
 166                                 return global_index;
 167                 } else {
 168                         return global_index;
 169                 }
 170
 171         } else {
 172                 for (i = 0; i < MAX_CMD_STATE_REQUEST; i++) {
 173                         if (evt_array[i].evt_type == evt_type && evt_array[i].actual_status != DONE ) {
 174                                 if (opcode != 0) {
 175                                         if (evt_array[i].req_opcode == opcode) {
 176                                                 if (evt_array[i].id < oldestid) {
 177                                                         oldestid = evt_array[i].id;
 178                                                         index = i;
 179                                                 }
 180                                         }
 181                                 } else {
 182                                         if (evt_array[i].id < oldestid) {
 183                                                 oldestid = evt_array[i].id;
 184                                                 index = i;
 185                                         }
 186                                 }
 187                         }
 188                 }
 189                 return index;
 190         }
 191         return -1;
 192 }
 193
 194 /******************************tiny_bt_functions functions*********************/
 195 int tiny_bt_init(__u8 dev_id)
 196 {
 197         struct hci_filter nf;
 198         int dd;
 199         expect_evt evt, *p_evt = &evt;
 200         connection_hci *p_conn = &connection;
 201         req_state status = PERMANENT;
 202         connection_state con_state = DISCONNECT;
 203
 204         memset(evt_array, 0, MAX_CMD_STATE_REQUEST * sizeof(expect_evt));
 205         evt_id = 0;
 206         global_index = 0;
 207         p_conn->con_id = 0;
 208         p_conn->con_state = con_state;
 209
 210         memset(p_evt, 0, sizeof(evt));
 211         p_evt->actual_status = status;
 212         p_evt->id = evt_id++;
 213         p_evt->evt_type = EVT_CMD_STATUS;
 214         p_evt->p_callback = callback_hci_all_commands;
 215         p_evt->p_data = NULL;
 216         add_evt_toarray(p_evt);
 217
 218         if ((dd = hw_bt_open_device(dev_id)) < 0) {
 219                 perror("device impossible to open\n");
 220                 return -1;
 221         }
 222
 223         hci_filter_clear(&nf);
 224         hci_filter_all_ptypes(&nf);
 225         hci_filter_all_events(&nf);
 226 //      hci_filter_set_opcode(swap_2_bytes(READ_BD_ADDR_CMD_OP),&nf);
 227
 228         if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0) {
 229                 perror("some problem with setsockopt\n");
 230                 return -1;
 231         }
 232         printf("init was succesful dd:%d\n",dd);
 233         return 0;
 234 }
 235
 236 int tiny_bt_finish()
 237 {
 238         int err;
 239
 240         if ((err = hw_bt_close_dev()) < 0) {
 241                 perror("Impossible to close filedes\n");
 242                 return -1;
 243         }
 244         printf("filedescriptor was closed\n");
 245         return 0;
 246 }
 247
 248 int tiny_bt_process()
 249 {
 250         int len, j, index;
 251         int err;
 252         static int inqRSSI_index = -1;
 253         hci_event_hdr *p_hdr;
 254         __u8 recbuf[HCI_MAX_EVENT_SIZE], *p_recbuf;
 255
 256         len = hw_bt_read(recbuf);
 257
 258         if (len) {
 259                 printf("Count of received bytes %d\n ", len);
 260                 for (j = 0; j < len; j++) {
 261                         printf(" %2.2X ",recbuf[j]);
 262                 }
 263                 printf("\n");
 264                 if (recbuf[0] == HCI_EVENT_PKT) {
 265                         p_hdr = (void *) (recbuf + 1);
 266                         p_recbuf = (void *) (recbuf + (1 + HCI_EVENT_HDR_SIZE));
 267                         if (p_hdr->evt == EVT_CMD_COMPLETE) {
 268                                 evt_cmd_complete *p_ccevt;
 269                                 p_ccevt = (void *) p_recbuf;
 270                                 if ((index = look_up_inarray(p_hdr->evt, swap_2_bytes(p_ccevt->opcode))) < 0) {
 271                                         err = -1;
 272                                         goto no_evt_exit;
 273                                 } else {
 274                                         evt_array[index].p_callback(evt_array[index].p_data, p_recbuf);
 275                                         if (evt_array[index].actual_status != PERMANENT)
 276                                                 evt_array[index].actual_status = DONE;
 277
 278                                 }
 279                         } else if (p_hdr->evt == EVT_INQUIRY_RESULT_WITH_RSSI || p_hdr->evt == EVT_INQUIRY_RESULT) {
 280                                 if ((index = look_up_inarray(EVT_INQUIRY_RESULT_WITH_RSSI, 0)) < 0) {
 281                                         err = -1;
 282                                         goto no_evt_exit;
 283                                 } else {
 284                                         evt_array[index].p_callback(evt_array[index].p_data, p_recbuf);
 285                                         if (evt_array[index].actual_status != PERMANENT)
 286                                                 evt_array[index].actual_status = DONE;
 287                                 }
 288
 289                         } else if (p_hdr->evt == EVT_CONN_REQUEST) {
 290                                 if ((index = look_up_inarray(EVT_CONN_REQUEST, 0)) < 0) {
 291                                         err = -1;
 292                                         goto no_evt_exit;
 293                                 } else {
 294                                         evt_array[index].p_callback(evt_array[index].p_data, p_recbuf);
 295                                         if (evt_array[index].actual_status != PERMANENT)
 296                                                 evt_array[index].actual_status = DONE;
 297                                 }
 298
 299                         } else if (p_hdr->evt == EVT_MAX_SLOTS_CHANGE || p_hdr->evt == EVT_NUM_COMP_PKTS) {
 300                                 /*TODO*/
 301                                 return 0;
 302                         } else if (p_hdr->evt == EVT_INQUIRY_COMPLETE) {
 303                                 if ((index = look_up_inarray(p_hdr->evt, 0)) < 0) {
 304                                         err = -1;
 305                                         goto no_evt_exit;
 306                                 }
 307                                 if ((inqRSSI_index = look_up_inarray(EVT_INQUIRY_RESULT_WITH_RSSI, 0)) < 0) {
 308                                         err = -1;
 309                                         goto no_evt_exit;
 310                                 } else {
 311                                         evt_array[index].p_callback(evt_array[index].p_data, p_recbuf);
 312                                         if (evt_array[index].actual_status != PERMANENT) {
 313                                                 evt_array[index].actual_status = DONE;
 314                                         }// mark inq result evt like a DONE
 315                                         if (evt_array[inqRSSI_index].actual_status != PERMANENT) {
 316                                                 free(evt_array[inqRSSI_index].p_data);
 317                                                 evt_array[inqRSSI_index].actual_status = DONE;
 318                                         }
 319                                 }
 320                         } else {
 321                                 if ((index = look_up_inarray(p_hdr->evt, 0)) < 0) {
 322                                         err = -1;
 323                                         goto no_evt_exit;
 324                                 } else {
 325                                         evt_array[index].p_callback(evt_array[index].p_data, p_recbuf);
 326                                         if (evt_array[index].actual_status != PERMANENT)
 327                                                 evt_array[index].actual_status = DONE;
 328                                 }
 329                         }
 330                         goto evt_found_exit;
 331                 } else if (recbuf[0] == HCI_ACLDATA_PKT) {
 332                         printf("Incoming data:\n");
 333                         printf("Count of received bytes %d\n ", len);
 334                         for(j = 0; j < len; j++) {
 335                                 printf("%2.2X ", recbuf[j]);
 336                         }
 337                         printf("\n");
 338                         /*TODO call some data callback for process data*/
 339                         return 1;
 340                 } else
 341                         goto packet_wrong;
 342         } else
 343                 goto no_data;
 344
 345
 346 no_evt_exit:
 347         printf("There is no awaiting evt like this\n");
 348         return err;
 349
 350 evt_found_exit:
 351         return 1;
 352
 353 packet_wrong:
 354         printf("Packet have bad format\n");
 355         return 0;
 356
 357 no_data:
 358         /*printf("There is no data on socket");*/
 359         return 0;
 360 }
 361
 362 int tiny_bt_read_bd_addr(bt_address *p_dest, void(*callback_app_read_bd_addr)(bt_address *p_address))
 363 {
 364         expect_evt evt, *p_evt = &evt;
 365         req_state status = ESTABLISHED;
 366         read_bd_addr_data *p_data;
 367
 368         memset(p_evt, 0, sizeof(evt));
 369         p_evt->actual_status = status;
 370         p_evt->id = evt_id++;
 371         p_evt->evt_type = EVT_CMD_COMPLETE;
 372         p_evt->req_opcode = READ_BD_ADDR_CMD_OP;
 373         p_evt->p_callback = &callback_hci_read_bd_addr;
 374
 375         p_data = malloc(sizeof(read_bd_addr_data));
 376         p_data->p_address = p_dest;
 377         p_data->callback_app_read_bd_addr = callback_app_read_bd_addr;
 378         p_evt->p_data = (void *) p_data;
 379         add_evt_toarray(p_evt);
 380
 381         if (send_hci_read_bd_addr_cmd() < 0) {
 382                 perror("send_hci_cmd error\n");
 383                 return -1;
 384         }
 385         return 0;
 386 }
 387
 388 int tiny_bt_read_local_name(char *p_name, void(*callback_app_read_local_name)(char *p_name))
 389 {
 390         expect_evt evt, *p_evt = &evt;
 391         req_state status = ESTABLISHED;
 392         read_local_name_data *p_data;
 393
 394         memset (p_evt, 0, sizeof(evt));
 395         p_evt->actual_status = status;
 396         p_evt->id = evt_id++;
 397         p_evt->evt_type = EVT_CMD_COMPLETE;
 398         p_evt->req_opcode = READ_LOCAL_NAME_CMD_OP;
 399         p_evt->p_callback = callback_hci_read_local_name;
 400
 401         p_data = malloc(sizeof(read_local_name_data));
 402         p_data->p_name = p_name;
 403         p_data->callback_app_read_local_name = callback_app_read_local_name;
 404         p_evt->p_data = (void *) p_data;
 405
 406         add_evt_toarray(p_evt);
 407         if(send_hci_read_local_name_cmd() < 0) {
 408                 perror("send_hci_cmd error\n");
 409                 return -1;
 410         }
 411         return 0;
 412 }
 413
 414 int tiny_bt_inquiry(bt_address *p_dest_addr, void(*callback_app_inquiry_RSSI)(bt_address *p_address), void(*callback_app_inquiry_complete)(void))
 415 {
 416         expect_evt evt,*p_evt = &evt;
 417         req_state status = ESTABLISHED;
 418         req_state istatus = ESTABLISHED;
 419         inquiry_RSSI_data *p_data;
 420         inquiry_complete_data *p_idata;
 421
 422         memset(p_evt, 0, sizeof(evt));
 423         p_evt->actual_status = status;
 424         p_evt->id = evt_id++;
 425         p_evt->evt_type = EVT_INQUIRY_RESULT_WITH_RSSI;
 426         p_evt->req_opcode = INQUIRY_CMD_OP;
 427         p_evt->p_callback = callback_hci_inquiry_RSSI;
 428
 429         p_data = malloc(sizeof(inquiry_RSSI_data));
 430         p_data->p_address = p_dest_addr;
 431         p_data->callback_app_inquiry_RSSI = callback_app_inquiry_RSSI;
 432         p_evt->p_data = (void *) p_data;
 433
 434         add_evt_toarray(p_evt);
 435
 436         memset(p_evt, 0, sizeof(evt));
 437         p_evt->actual_status = istatus;
 438         p_evt->id = evt_id++;
 439         p_evt->evt_type = EVT_INQUIRY_COMPLETE;
 440         p_evt->req_opcode = INQUIRY_CMD_OP;
 441         p_evt->p_callback = callback_hci_inquiry_comple;
 442
 443         p_idata = malloc(sizeof(inquiry_complete_data));
 444         p_idata->callback_app_inquiry_complete = callback_app_inquiry_complete;
 445         p_evt->p_data = (void *)p_idata;
 446
 447         add_evt_toarray(p_evt);
 448
 449         if(send_hci_inquiry_cmd()<0) {
 450                 perror("send_hci_cmd error");
 451                 return -1;
 452         }
 453         return 0;
 454 }
 455
 456 void tiny_bt_inquiry_register_again(bt_address *p_dest_addr, void(*callback_app_inquiry_RSSI)(bt_address *p_address))
 457 {
 458         expect_evt evt, *p_evt = &evt;
 459         req_state status = ESTABLISHED;
 460         inquiry_RSSI_data *p_data;
 461
 462         memset(p_evt, 0, sizeof(evt));
 463         p_evt->actual_status = status;
 464         p_evt->id = evt_id++;
 465         p_evt->evt_type = EVT_INQUIRY_RESULT_WITH_RSSI;
 466         p_evt->req_opcode = INQUIRY_CMD_OP;
 467         p_evt->p_callback = callback_hci_inquiry_RSSI;
 468
 469         p_data = malloc(sizeof(inquiry_RSSI_data));
 470         p_data->p_address = p_dest_addr;
 471         p_data->callback_app_inquiry_RSSI = callback_app_inquiry_RSSI;
 472         p_evt->p_data = (void *) p_data;
 473
 474         add_evt_toarray(p_evt);
 475 }
 476
 477 int tiny_bt_connect(bt_address *p_dest_addr, __u16 *p_handle, void( *callback_app_connection_complete)(__u16 *p_handle))
 478 {
 479         expect_evt evt, *p_evt = &evt;
 480         req_state status = ESTABLISHED;
 481         connection_complete_data *p_data;
 482
 483         memset(p_evt, 0, sizeof(evt));
 484         p_evt->actual_status = status;
 485         p_evt->id = evt_id++;
 486         p_evt->evt_type = EVT_CONN_COMPLETE;
 487         p_evt->req_opcode = CREATE_CONNECTION_CMD_OP;
 488         p_evt->p_callback = callback_hci_create_connection;
 489
 490         p_data = malloc(sizeof(connection_complete_data));
 491         p_data->p_handle = p_handle;
 492         p_data->callback_app_connection_complete = callback_app_connection_complete;
 493         p_evt->p_data = (void *) p_data;
 494
 495         add_evt_toarray (p_evt);
 496         if (send_hci_create_connection_cmd(p_dest_addr) < 0) {
 497                 perror("send_hci_cmd error\n");
 498                 return -1;
 499         }
 500         return 0;
 501
 502 }
 503
 504 void tiny_bt_wait_for_connection(bt_address *p_dest_addr, void(*callback_app_conection_request)(bt_address *p_address))
 505 {
 506         expect_evt evt, *p_evt = &evt;
 507         req_state status = ESTABLISHED;
 508         connection_request_data *p_data;
 509
 510         memset(p_evt, 0, sizeof(evt));
 511         p_evt->actual_status = status;
 512         p_evt->id = evt_id++;
 513         p_evt->evt_type = EVT_CONN_REQUEST;
 514         p_evt->p_callback = callback_hci_connection_request;
 515
 516         p_data = malloc(sizeof(connection_request_data));
 517         p_data->p_address = p_dest_addr;
 518         p_data->callback_app_connection_request = callback_app_conection_request;
 519         p_evt->p_data = (void*) p_data;
 520
 521         add_evt_toarray(p_evt);
 522 }
 523
 524 int tiny_bt_accept_connection(bt_address *p_dest_addr, __u16 *p_handle, void(*callback_app_connection_complete)(__u16 *p_handle))
 525 {
 526         expect_evt evt, *p_evt = &evt;
 527         req_state status = ESTABLISHED;
 528         connection_complete_data *p_data;
 529
 530         memset(p_evt, 0, sizeof(evt));
 531         p_evt->actual_status = status;
 532         p_evt->id = evt_id++;
 533         p_evt->evt_type = EVT_CONN_COMPLETE;
 534         p_evt->req_opcode = ACCEPT_CONNECTION_REQ_OP;
 535         p_evt->p_callback = callback_hci_create_connection;
 536
 537         p_data = malloc(sizeof(connection_complete_data));
 538         p_data->p_handle = p_handle;
 539         p_data->callback_app_connection_complete = callback_app_connection_complete;
 540         p_evt->p_data = (void *) p_data;
 541
 542         add_evt_toarray(p_evt);
 543         // and register disconnect event
 544         if (send_hci_accept_conn_req_cmd(p_dest_addr) < 0) {
 545                 perror("send_hci_cmd error\n");
 546                 return -1;
 547         }
 548         return 0;
 549 }
 550
 551 void tiny_bt_disconnect_register(void(*callback_app_disconnect)(__u16 *p_handle, __u8 *p_reason))
 552 {
 553         expect_evt evt, *p_evt = &evt;
 554         req_state status = ESTABLISHED;
 555         disconnect_data *p_data;
 556
 557         memset(p_evt, 0, sizeof(evt));
 558         p_evt->actual_status = status;
 559         p_evt->id = evt_id++;
 560         p_evt->evt_type = EVT_DISCONN_COMPLETE;
 561         p_evt->p_callback = callback_hci_disconnect;
 562
 563         p_data = malloc(sizeof(disconnect_data));
 564         p_data->callback_app_disconnect = callback_app_disconnect;
 565         p_evt->p_data = (void *) p_data;
 566
 567         add_evt_toarray(p_evt);
 568 }
 569
 570 int tiny_bt_disconnect(__u16 *p_handle, void(*callback_app_disconnect)(__u16 *p_handle, __u8 *p_reason))
 571 {
 572         expect_evt evt, *p_evt = &evt;
 573         req_state status = ESTABLISHED;
 574         disconnect_data *p_data;
 575
 576         memset(p_evt, 0, sizeof(evt));
 577         p_evt->actual_status = status;
 578         p_evt->id = evt_id++;
 579         p_evt->evt_type = EVT_DISCONN_COMPLETE;
 580         p_evt->p_callback = callback_hci_disconnect;
 581
 582         p_data = malloc(sizeof(disconnect_data));
 583         p_data->callback_app_disconnect = callback_app_disconnect;
 584         p_evt->p_data = (void *) p_data;
 585
 586         add_evt_toarray(p_evt);
 587
 588         if (send_hci_disconnect_cmd(*p_handle) < 0) {
 589                 perror ("send_hci_cmd error\n");
 590                 return -1;
 591         }
 592         return 0;
 593
 594 }
 595
 596 int tiny_bt_send_data(char *p_data, __u16 lenght, __u16 *p_chandle, __u16 PB_flag, __u16 B_flag)
 597 {
 598         if (send_hci_data(p_data, lenght, p_chandle, PB_flag, B_flag) < 0) {
 599                 perror ("send_hci_cmd error\n");
 600                 return -1;
 601         }
 602         return 0;
 603 }
 604
 605