← Back to branch summary

~cyphermox/bluez/5.23

« back to all changes in this revision

Viewing changes to lib/hci.c

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-28 13:44:34 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20100728134434-uf57qfi8yi050eil
Tags: 4.69-1
http://bugs.debian.org/589727
* New upstream release (Closes: #589727).
* Update debian/control.
  - bumped standards-version to 3.9.1.
* Update libbluetooth3.symbols.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/hci.c
1093
1093
        hci_filter_set_ptype(HCI_EVENT_PKT,  &nf);
1094
1094
        hci_filter_set_event(EVT_CMD_STATUS, &nf);
1095
1095
        hci_filter_set_event(EVT_CMD_COMPLETE, &nf);
 
1096
        hci_filter_set_event(EVT_LE_META_EVENT, &nf);
1096
1097
        hci_filter_set_event(r->event, &nf);
1097
1098
        hci_filter_set_opcode(opcode, &nf);
1098
1099
        if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0)
1106
1107
                evt_cmd_complete *cc;
1107
1108
                evt_cmd_status *cs;
1108
1109
                evt_remote_name_req_complete *rn;
 
1110
                evt_le_meta_event *me;
1109
1111
                remote_name_req_cp *cp;
1110
1112
                int len;
1111
1113
 
1186
1188
                        memcpy(r->rparam, ptr, r->rlen);
1187
1189
                        goto done;
1188
1190
 
 
1191
                case EVT_LE_META_EVENT:
 
1192
                        me = (void *) ptr;
 
1193
 
 
1194
                        if (me->subevent != r->event)
 
1195
                                continue;
 
1196
 
 
1197
                        len -= 1;
 
1198
                        r->rlen = MIN(len, r->rlen);
 
1199
                        memcpy(r->rparam, me->data, r->rlen);
 
1200
                        goto done;
 
1201
 
1189
1202
                default:
1190
1203
                        if (hdr->evt != r->event)
1191
1204
                                break;
2591
2604
        *accuracy = rp.accuracy;
2592
2605
        return 0;
2593
2606
}
 
2607
 
 
2608
int hci_le_set_scan_enable(int dd, uint8_t enable, uint8_t filter_dup)
 
2609
{
 
2610
        struct hci_request rq;
 
2611
        le_set_scan_enable_cp scan_cp;
 
2612
        uint8_t status;
 
2613
 
 
2614
        memset(&scan_cp, 0, sizeof(scan_cp));
 
2615
        scan_cp.enable = enable;
 
2616
        scan_cp.filter_dup = filter_dup;
 
2617
 
 
2618
        memset(&rq, 0, sizeof(rq));
 
2619
        rq.ogf = OGF_LE_CTL;
 
2620
        rq.ocf = OCF_LE_SET_SCAN_ENABLE;
 
2621
        rq.cparam = &scan_cp;
 
2622
        rq.clen = LE_SET_SCAN_ENABLE_CP_SIZE;
 
2623
        rq.rparam = &status;
 
2624
        rq.rlen = 1;
 
2625
 
 
2626
        if (hci_send_req(dd, &rq, 100) < 0)
 
2627
                return -1;
 
2628
 
 
2629
        if (status) {
 
2630
                errno = EIO;
 
2631
                return -1;
 
2632
        }
 
2633
 
 
2634
        return 0;
 
2635
}
 
2636
 
 
2637
int hci_le_set_scan_parameters(int dd, uint8_t type,
 
2638
                                        uint16_t interval, uint16_t window,
 
2639
                                        uint8_t own_type, uint8_t filter)
 
2640
{
 
2641
        struct hci_request rq;
 
2642
        le_set_scan_parameters_cp param_cp;
 
2643
        uint8_t status;
 
2644
 
 
2645
        memset(&param_cp, 0, sizeof(param_cp));
 
2646
        param_cp.type = type;
 
2647
        param_cp.interval = interval;
 
2648
        param_cp.window = window;
 
2649
        param_cp.own_bdaddr_type = own_type;
 
2650
        param_cp.filter = filter;
 
2651
 
 
2652
        memset(&rq, 0, sizeof(rq));
 
2653
        rq.ogf = OGF_LE_CTL;
 
2654
        rq.ocf = OCF_LE_SET_SCAN_PARAMETERS;
 
2655
        rq.cparam = &param_cp;
 
2656
        rq.clen = LE_SET_SCAN_PARAMETERS_CP_SIZE;
 
2657
        rq.rparam = &status;
 
2658
        rq.rlen = 1;
 
2659
 
 
2660
        if (hci_send_req(dd, &rq, 100) < 0)
 
2661
                return -1;
 
2662
 
 
2663
        if (status) {
 
2664
                errno = EIO;
 
2665
                return -1;
 
2666
        }
 
2667
 
 
2668
        return 0;
 
2669
}
 
2670
 
 
2671
int hci_le_set_advertise_enable(int dd, uint8_t enable)
 
2672
{
 
2673
        struct hci_request rq;
 
2674
        le_set_advertise_enable_cp adv_cp;
 
2675
        uint8_t status;
 
2676
 
 
2677
        memset(&adv_cp, 0, sizeof(adv_cp));
 
2678
        adv_cp.enable = enable;
 
2679
 
 
2680
        memset(&rq, 0, sizeof(rq));
 
2681
        rq.ogf = OGF_LE_CTL;
 
2682
        rq.ocf = OCF_LE_SET_ADVERTISE_ENABLE;
 
2683
        rq.cparam = &adv_cp;
 
2684
        rq.clen = LE_SET_ADVERTISE_ENABLE_CP_SIZE;
 
2685
        rq.rparam = &status;
 
2686
        rq.rlen = 1;
 
2687
 
 
2688
        if (hci_send_req(dd, &rq, 100) < 0)
 
2689
                return -1;
 
2690
 
 
2691
        if (status) {
 
2692
                errno = EIO;
 
2693
                return -1;
 
2694
        }
 
2695
 
 
2696
        return 0;
 
2697
}
 
2698
 
 
2699
int hci_le_create_conn(int dd, uint16_t interval, uint16_t window,
 
2700
                uint8_t initiator_filter, uint8_t peer_bdaddr_type,
 
2701
                bdaddr_t peer_bdaddr, uint8_t own_bdaddr_type,
 
2702
                uint16_t min_interval,  uint16_t max_interval,
 
2703
                uint16_t latency, uint16_t supervision_timeout,
 
2704
                uint16_t min_ce_length, uint16_t max_ce_length,
 
2705
                uint16_t *handle, int to)
 
2706
{
 
2707
        struct hci_request rq;
 
2708
        le_create_connection_cp create_conn_cp;
 
2709
        evt_le_connection_complete conn_complete_rp;
 
2710
 
 
2711
        memset(&create_conn_cp, 0, sizeof(create_conn_cp));
 
2712
        create_conn_cp.interval = interval;
 
2713
        create_conn_cp.window = window;
 
2714
        create_conn_cp.initiator_filter = initiator_filter;
 
2715
        create_conn_cp.peer_bdaddr_type = peer_bdaddr_type;
 
2716
        create_conn_cp.peer_bdaddr = peer_bdaddr;
 
2717
        create_conn_cp.own_bdaddr_type = own_bdaddr_type;
 
2718
        create_conn_cp.min_interval = min_interval;
 
2719
        create_conn_cp.max_interval = max_interval;
 
2720
        create_conn_cp.latency = latency;
 
2721
        create_conn_cp.supervision_timeout = supervision_timeout;
 
2722
        create_conn_cp.min_ce_length = min_ce_length;
 
2723
        create_conn_cp.max_ce_length = max_ce_length;
 
2724
 
 
2725
        memset(&rq, 0, sizeof(rq));
 
2726
        rq.ogf = OGF_LE_CTL;
 
2727
        rq.ocf = OCF_LE_CREATE_CONN;
 
2728
        rq.event = EVT_LE_CONN_COMPLETE;
 
2729
        rq.cparam = &create_conn_cp;
 
2730
        rq.clen = LE_CREATE_CONN_CP_SIZE;
 
2731
        rq.rparam = &conn_complete_rp;
 
2732
        rq.rlen = EVT_CONN_COMPLETE_SIZE;
 
2733
 
 
2734
        if (hci_send_req(dd, &rq, to) < 0)
 
2735
                return -1;
 
2736
 
 
2737
        if (conn_complete_rp.status) {
 
2738
                errno = EIO;
 
2739
                return -1;
 
2740
        }
 
2741
 
 
2742
        if (handle)
 
2743
                *handle = conn_complete_rp.handle;
 
2744
 
 
2745
        return 0;
 
2746
}