Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 74bf580b authored by Jakub Pawlowski's avatar Jakub Pawlowski
Browse files

Remove return value of BTM_VendorSpecificCommand function

The return value of BTM_VendorSpecificCommand is currently just an
information wether the callback was passed to it or not, but many places
through stack use this value as error indication. Remove it.

Test: unit tests pass
Change-Id: Idf73fc49fb25e52c3aeb64f2305b4498ecacd9a4
parent 5c34433b
Loading
Loading
Loading
Loading
+54 −111
Original line number Diff line number Diff line
@@ -486,20 +486,10 @@ tBTM_STATUS btm_ble_update_pf_local_name(tBTM_BLE_SCAN_COND_OP action,
    }

    /* send local name filter */
    if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
                              len,
                              param,
                              btm_ble_scan_pf_cmpl_cback))
            != BTM_NO_RESOURCES)
    {
    BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF, len, param,
                              btm_ble_scan_pf_cmpl_cback);
    memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
    }
    else
    {
        BTM_TRACE_ERROR("Local Name PF filter update failed");
    }

    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -637,19 +627,10 @@ tBTM_STATUS btm_ble_update_pf_manu_data(tBTM_BLE_SCAN_COND_OP action,
    }

    /* send manufacturer*/
    if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
                              len,
                              param,
                              btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES)
    {
    BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF, len, param,
                              btm_ble_scan_pf_cmpl_cback);
    memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
    }
    else
    {
        BTM_TRACE_ERROR("manufacturer data PF filter update failed");
    }

    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -727,7 +708,7 @@ uint8_t btm_ble_cs_update_pf_counter(tBTM_BLE_SCAN_COND_OP action,
** Description      this function update(add,delete or clear) the address filter of adv.
**
**
** Returns          BTM_SUCCESS if sucessful,
** Returns          BTM_CMD_STARTED if sucessful,
**                  BTM_ILLEGAL_VALUE if paramter is not valid.
**
*******************************************************************************/
@@ -737,7 +718,6 @@ tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action,
{
    uint8_t     param[BTM_BLE_META_ADDR_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH],
                * p= param;
    tBTM_STATUS st = BTM_ILLEGAL_VALUE;
    tBLE_BD_ADDR *p_addr = (p_cond == NULL) ? NULL : &p_cond->target_addr;

    memset(param, 0, BTM_BLE_META_ADDR_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH);
@@ -752,24 +732,18 @@ tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action,
        BTM_BLE_SCAN_COND_DELETE == action)
    {
        if (NULL == p_addr)
            return st;
            return BTM_ILLEGAL_VALUE;

        BDADDR_TO_STREAM(p, p_addr->bda);
        UINT8_TO_STREAM(p, p_addr->type);
    }
    /* send address filter */
    if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
    BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                              (uint8_t)(BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_META_ADDR_LEN),
                              param,
                              btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES)
    {
                              btm_ble_scan_pf_cmpl_cback);
    memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
    }
    else
    {
        BTM_TRACE_ERROR("Broadcaster Address Filter Update failed");
    }
    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -779,7 +753,7 @@ tBTM_STATUS btm_ble_update_addr_filter(tBTM_BLE_SCAN_COND_OP action,
** Description      this function update(add,delete or clear) service UUID filter.
**
**
** Returns          BTM_SUCCESS if sucessful,
** Returns          BTM_CMD_STARTED if sucessful,
**                  BTM_ILLEGAL_VALUE if paramter is not valid.
**
*******************************************************************************/
@@ -793,7 +767,6 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
    uint8_t     param[BTM_BLE_META_UUID_LEN + BTM_BLE_ADV_FILT_META_HDR_LENGTH],
                * p= param,
                len = BTM_BLE_ADV_FILT_META_HDR_LENGTH;
    tBTM_STATUS st = BTM_ILLEGAL_VALUE;
    tBTM_BLE_PF_UUID_COND *p_uuid_cond;
    uint8_t         evt_type;

@@ -813,7 +786,7 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
    if (NULL == p_uuid_cond && action != BTM_BLE_SCAN_COND_CLEAR)
    {
        BTM_TRACE_ERROR("Illegal param for add/delete UUID filter");
        return st;
        return BTM_ILLEGAL_VALUE;
    }

    /* need to add address filter first, if adding per bda UUID filter without address filter */
@@ -831,15 +804,10 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
        UINT8_TO_STREAM(p, p_uuid_cond->p_target_addr->type);

        /* send address filter */
        if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
        BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                                  (uint8_t)(BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_META_ADDR_LEN),
                                  param,
                                  btm_ble_scan_pf_cmpl_cback)) == BTM_NO_RESOURCES)
        {
            BTM_TRACE_ERROR("Update Address filter into controller failed.");
            return st;
        }

                                  btm_ble_scan_pf_cmpl_cback);
        btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_ADDR, cb_evt, ref_value, NULL, NULL);
        BTM_TRACE_DEBUG("Updated Address filter");
    }
@@ -904,23 +872,17 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
    }

    /* send UUID filter update */
    if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
    BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                              len,
                              param,
                              btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES)
    {
                              btm_ble_scan_pf_cmpl_cback);
    if (p_uuid_cond && p_uuid_cond->p_target_addr)
        memcpy(&btm_ble_adv_filt_cb.cur_filter_target, p_uuid_cond->p_target_addr,
                sizeof(tBLE_BD_ADDR));
    else
        memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
    }
    else
    {
        BTM_TRACE_ERROR("UUID filter udpating failed");
    }

    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -930,7 +892,7 @@ tBTM_STATUS btm_ble_update_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
** Description      clear all adv payload filter by de-select all the adv pf feature bits
**
**
** Returns          BTM_SUCCESS if sucessful,
** Returns          BTM_CMD_STARTED if sucessful,
**                  BTM_ILLEGAL_VALUE if paramter is not valid.
**
*******************************************************************************/
@@ -1016,18 +978,15 @@ tBTM_STATUS btm_ble_clear_scan_pf_filter(tBTM_BLE_SCAN_COND_OP action,
    /* set logic condition as OR as default */
    UINT8_TO_STREAM(p, BTM_BLE_PF_LOGIC_OR);

    if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
    BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                               (uint8_t)(BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_PF_FEAT_SEL_LEN),
                                param,
                                btm_ble_scan_pf_cmpl_cback))
            != BTM_NO_RESOURCES)
    {
                                btm_ble_scan_pf_cmpl_cback);
    if (p_target)
        memcpy(&btm_ble_adv_filt_cb.cur_filter_target, p_target, sizeof(tBLE_BD_ADDR));
    else
        memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
    }
    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -1052,14 +1011,13 @@ tBTM_STATUS BTM_BleAdvFilterParamSetup(int action, tBTM_BLE_PF_FILT_INDEX filt_i
                                tBLE_BD_ADDR *p_target, tBTM_BLE_PF_PARAM_CBACK *p_cmpl_cback,
                                tBTM_BLE_REF_VALUE ref_value)
{
    tBTM_STATUS st = BTM_WRONG_MODE;
    tBTM_BLE_PF_COUNT *p_bda_filter = NULL;
    uint8_t len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN +
                BTM_BLE_ADV_FILT_TRACK_NUM;
    uint8_t param[len], *p;

    if (BTM_SUCCESS  != btm_ble_obtain_vsc_details())
        return st;
        return BTM_WRONG_MODE;

    p = param;
    memset(param, 0, len);
@@ -1071,7 +1029,7 @@ tBTM_STATUS BTM_BleAdvFilterParamSetup(int action, tBTM_BLE_PF_FILT_INDEX filt_i
        if (NULL == p_bda_filter)
        {
           BTM_TRACE_ERROR("BD Address not found!");
           return st;
           return BTM_WRONG_MODE;
        }

        BTM_TRACE_DEBUG("BTM_BleAdvFilterParamSetup : Feat mask:%d", p_filt_params->feat_seln);
@@ -1114,14 +1072,10 @@ tBTM_STATUS BTM_BleAdvFilterParamSetup(int action, tBTM_BLE_PF_FILT_INDEX filt_i
            len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN +
                  BTM_BLE_ADV_FILT_TRACK_NUM;

        if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
        BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                                  (uint8_t)len,
                                  param,
                                 btm_ble_scan_pf_cmpl_cback))
               == BTM_NO_RESOURCES)
        {
            return st;
        }
                                  btm_ble_scan_pf_cmpl_cback);
        btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL, BTM_BLE_FILT_ADV_PARAM,
                                 ref_value, NULL, p_cmpl_cback);
    }
@@ -1134,14 +1088,10 @@ tBTM_STATUS BTM_BleAdvFilterParamSetup(int action, tBTM_BLE_PF_FILT_INDEX filt_i
        /* Filter index */
        UINT8_TO_STREAM(p, filt_index);

        if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
        BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                                  (uint8_t)(BTM_BLE_ADV_FILT_META_HDR_LENGTH),
                                  param,
                                 btm_ble_scan_pf_cmpl_cback))
               == BTM_NO_RESOURCES)
        {
            return st;
        }
                                  btm_ble_scan_pf_cmpl_cback);
        btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL,  BTM_BLE_FILT_ADV_PARAM,
                                 ref_value, NULL, p_cmpl_cback);
    }
@@ -1155,19 +1105,14 @@ tBTM_STATUS BTM_BleAdvFilterParamSetup(int action, tBTM_BLE_PF_FILT_INDEX filt_i
        UINT8_TO_STREAM(p, BTM_BLE_META_PF_FEAT_SEL);
        UINT8_TO_STREAM(p, BTM_BLE_SCAN_COND_CLEAR);

        if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
        BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                                  (uint8_t)(BTM_BLE_ADV_FILT_META_HDR_LENGTH-1),
                                  param,
                                 btm_ble_scan_pf_cmpl_cback))
               == BTM_NO_RESOURCES)
        {
            return st;
        }
                                  btm_ble_scan_pf_cmpl_cback);
        btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_FEAT_SEL,  BTM_BLE_FILT_ADV_PARAM,
                                 ref_value, NULL, p_cmpl_cback);
    }

    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -1202,15 +1147,13 @@ tBTM_STATUS BTM_BleEnableDisableFilterFeature(uint8_t enable,
    /* enable adv data payload filtering */
    UINT8_TO_STREAM(p, enable);

    if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
    BTM_VendorSpecificCommand(HCI_BLE_ADV_FILTER_OCF,
                              BTM_BLE_PCF_ENABLE_LEN, param,
                              btm_ble_scan_pf_cmpl_cback)) == BTM_CMD_STARTED)
    {
                              btm_ble_scan_pf_cmpl_cback);
    btm_ble_adv_filt_cb.p_filt_stat_cback = p_stat_cback;
    btm_ble_advfilt_enq_op_q(enable, BTM_BLE_META_PF_ENABLE, BTM_BLE_FILT_ENABLE_DISABLE,
                             ref_value, NULL, NULL);
    }
    return st;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
+33 −112
Original line number Diff line number Diff line
@@ -314,13 +314,10 @@ void btm_ble_batchscan_deq_op_q(uint8_t *p_opcode,tBTM_BLE_BATCH_SCAN_STATE *cur
** Parameters       scan_mode - The mode for which the reports are to be read out from the controller
**                  ref_value - Reference value
**
** Returns          status
**
*******************************************************************************/
tBTM_STATUS btm_ble_read_batchscan_reports(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
void btm_ble_read_batchscan_reports(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
                                          tBTM_BLE_REF_VALUE ref_value)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    uint8_t param[BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN], *pp;
    pp = param;

@@ -329,24 +326,14 @@ tBTM_STATUS btm_ble_read_batchscan_reports(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
    UINT8_TO_STREAM (pp, BTM_BLE_BATCH_SCAN_READ_RESULTS);
    UINT8_TO_STREAM (pp, scan_mode);

    if ((status = BTM_VendorSpecificCommand (HCI_BLE_BATCH_SCAN_OCF,
            BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN, param, btm_ble_batchscan_vsc_cmpl_cback))
            != BTM_CMD_STARTED)
    {
        BTM_TRACE_ERROR("btm_ble_read_batchscan_reports %d", status);
        return BTM_ILLEGAL_VALUE;
    }
    BTM_VendorSpecificCommand(HCI_BLE_BATCH_SCAN_OCF,
            BTM_BLE_BATCH_SCAN_READ_RESULTS_LEN, param, btm_ble_batchscan_vsc_cmpl_cback);

    if (BTM_CMD_STARTED == status)
    {
    /* The user needs to be provided scan read reports event */
    btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_READ_RESULTS, ble_batchscan_cb.cur_state,
                               BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, ref_value);
}

    return status;
}

/*******************************************************************************
**
** Function         btm_ble_batchscan_vsc_cmpl_cback
@@ -368,7 +355,6 @@ void btm_ble_batchscan_vsc_cmpl_cback (tBTM_VSC_CMPL *p_params)
    uint8_t report_format = 0, num_records = 0, cb_evt = 0;
    uint16_t data_len = 0;
    tBTM_BLE_BATCH_SCAN_STATE cur_state = 0;
    tBTM_STATUS btm_status = 0;
    uint8_t *p_data = NULL;

    if (len < 2)
@@ -468,16 +454,7 @@ void btm_ble_batchscan_vsc_cmpl_cback (tBTM_VSC_CMPL *p_params)
                    {
                        btm_ble_batchscan_enq_rep_data(report_format, num_records, p, len-4);
                        /* More records could be in the buffer and needs to be pulled out */
                        btm_status = btm_ble_read_batchscan_reports(report_format, ref_value);
                        if (BTM_CMD_STARTED != btm_status)
                        {
                            btm_ble_batchscan_deq_rep_data(report_format, &ref_value, &num_records,
                                                           &p_data, &data_len);
                            /* Send whatever is available, in case of a command failure */
                            if (NULL != ble_batchscan_cb.p_scan_rep_cback && NULL != p_data)
                                ble_batchscan_cb.p_scan_rep_cback(ref_value,report_format,
                                                 num_records, data_len, p_data, status);
                        }
                        btm_ble_read_batchscan_reports(report_format, ref_value);
                    }
                }
            }
@@ -501,13 +478,10 @@ void btm_ble_batchscan_vsc_cmpl_cback (tBTM_VSC_CMPL *p_params)
**                  batch_scan_trunc_max -Max storage space (in %) allocated to truncated scanning
**                  batch_scan_notify_threshold - Setup notification level based on total space
**
** Returns          status
**
*******************************************************************************/
tBTM_STATUS btm_ble_set_storage_config(uint8_t batch_scan_full_max, uint8_t batch_scan_trunc_max,
void btm_ble_set_storage_config(uint8_t batch_scan_full_max, uint8_t batch_scan_trunc_max,
                                       uint8_t batch_scan_notify_threshold)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    uint8_t param[BTM_BLE_BATCH_SCAN_STORAGE_CFG_LEN], *pp;

    pp = param;
@@ -518,15 +492,9 @@ tBTM_STATUS btm_ble_set_storage_config(uint8_t batch_scan_full_max, uint8_t batc
    UINT8_TO_STREAM (pp, batch_scan_trunc_max);
    UINT8_TO_STREAM (pp, batch_scan_notify_threshold);

    if ((status = BTM_VendorSpecificCommand (HCI_BLE_BATCH_SCAN_OCF,
    BTM_VendorSpecificCommand(HCI_BLE_BATCH_SCAN_OCF,
                BTM_BLE_BATCH_SCAN_STORAGE_CFG_LEN, param,
                btm_ble_batchscan_vsc_cmpl_cback))!= BTM_CMD_STARTED)
    {
        BTM_TRACE_ERROR("btm_ble_set_storage_config %d", status);
        return BTM_ILLEGAL_VALUE;
    }

    return status;
                btm_ble_batchscan_vsc_cmpl_cback);
}

/*******************************************************************************
@@ -541,14 +509,11 @@ tBTM_STATUS btm_ble_set_storage_config(uint8_t batch_scan_full_max, uint8_t batc
**                  discard_rule -Discard rules
**                  addr_type - Address type
**
** Returns          status
**
*******************************************************************************/
tBTM_STATUS btm_ble_set_batchscan_param(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
void btm_ble_set_batchscan_param(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
                     uint32_t scan_interval, uint32_t scan_window, tBLE_ADDR_TYPE addr_type,
                     tBTM_BLE_DISCARD_RULE discard_rule)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    uint8_t scan_param[BTM_BLE_BATCH_SCAN_PARAM_CONFIG_LEN], *pp_scan;

    pp_scan = scan_param;
@@ -565,15 +530,9 @@ tBTM_STATUS btm_ble_set_batchscan_param(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
    UINT8_TO_STREAM (pp_scan, addr_type);
    UINT8_TO_STREAM (pp_scan, discard_rule);

    if ((status = BTM_VendorSpecificCommand (HCI_BLE_BATCH_SCAN_OCF,
    BTM_VendorSpecificCommand(HCI_BLE_BATCH_SCAN_OCF,
            BTM_BLE_BATCH_SCAN_PARAM_CONFIG_LEN,
            scan_param, btm_ble_batchscan_vsc_cmpl_cback))!= BTM_CMD_STARTED)
    {
        BTM_TRACE_ERROR("btm_ble_set_batchscan_param %d", status);
        return BTM_ILLEGAL_VALUE;
    }

    return status;
            scan_param, btm_ble_batchscan_vsc_cmpl_cback);
}

/*******************************************************************************
@@ -584,12 +543,9 @@ tBTM_STATUS btm_ble_set_batchscan_param(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
**
** Parameters       enable_disable: true - enable, false - disable
**
** Returns          status
**
*******************************************************************************/
tBTM_STATUS btm_ble_enable_disable_batchscan(bool    should_enable)
void btm_ble_enable_disable_batchscan(bool    should_enable)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    uint8_t shld_enable = 0x01;
    uint8_t enable_param[BTM_BLE_BATCH_SCAN_ENB_DISB_LEN], *pp_enable;

@@ -604,30 +560,19 @@ tBTM_STATUS btm_ble_enable_disable_batchscan(bool should_enable)
        UINT8_TO_STREAM (pp_enable, BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE);
        UINT8_TO_STREAM (pp_enable, shld_enable);

        if ((status = BTM_VendorSpecificCommand(HCI_BLE_BATCH_SCAN_OCF,
        BTM_VendorSpecificCommand(HCI_BLE_BATCH_SCAN_OCF,
                 BTM_BLE_BATCH_SCAN_ENB_DISB_LEN, enable_param,
                 btm_ble_batchscan_vsc_cmpl_cback)) != BTM_CMD_STARTED)
        {
            status = BTM_MODE_UNSUPPORTED;
            BTM_TRACE_ERROR("btm_ble_enable_disable_batchscan %d", status);
            return BTM_ILLEGAL_VALUE;
        }
                 btm_ble_batchscan_vsc_cmpl_cback);
    }
    else
    if ((status = btm_ble_set_batchscan_param(BTM_BLE_BATCH_SCAN_MODE_DISABLE,
        btm_ble_set_batchscan_param(BTM_BLE_BATCH_SCAN_MODE_DISABLE,
                   ble_batchscan_cb.scan_interval, ble_batchscan_cb.scan_window,
                   ble_batchscan_cb.addr_type, ble_batchscan_cb.discard_rule)) != BTM_CMD_STARTED)
    {
         status = BTM_MODE_UNSUPPORTED;
         BTM_TRACE_ERROR("btm_ble_enable_disable_batchscan %d", status);
         return BTM_ILLEGAL_VALUE;
    }
                   ble_batchscan_cb.addr_type, ble_batchscan_cb.discard_rule);

    if (should_enable)
        ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLE_CALLED;
    else
        ble_batchscan_cb.cur_state = BTM_BLE_SCAN_DISABLE_CALLED;
    return status;
}

/*******************************************************************************
@@ -654,7 +599,6 @@ tBTM_STATUS BTM_BleSetStorageConfig(uint8_t batch_scan_full_max, uint8_t batch_s
                                        tBTM_BLE_SCAN_REP_CBACK* p_rep_cback,
                                        tBTM_BLE_REF_VALUE ref_value)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    tBTM_BLE_VSC_CB cmn_ble_vsc_cb;

    BTM_TRACE_EVENT (" BTM_BleSetStorageConfig: %d, %d, %d, %d, %d",
@@ -689,24 +633,19 @@ tBTM_STATUS BTM_BleSetStorageConfig(uint8_t batch_scan_full_max, uint8_t batch_s
         BTM_BLE_SCAN_DISABLED_STATE == ble_batchscan_cb.cur_state ||
         BTM_BLE_SCAN_DISABLE_CALLED == ble_batchscan_cb.cur_state)
    {
        status = btm_ble_enable_disable_batchscan(true);
        if (BTM_CMD_STARTED != status)
            return status;

        btm_ble_enable_disable_batchscan(true);
        ble_batchscan_cb.cur_state = BTM_BLE_SCAN_ENABLE_CALLED;
        btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE,
                                    BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value);
    }

    status = btm_ble_set_storage_config(batch_scan_full_max, batch_scan_trunc_max,
    btm_ble_set_storage_config(batch_scan_full_max, batch_scan_trunc_max,
                               batch_scan_notify_threshold);
    if (BTM_CMD_STARTED != status)
       return status;
            /* The user needs to be provided scan config storage event */
     btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_STORAGE_PARAM, ble_batchscan_cb.cur_state,
                                   BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, ref_value);

    return status;
    return BTM_CMD_STARTED;
}


@@ -729,7 +668,6 @@ tBTM_STATUS BTM_BleEnableBatchScan(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
            uint32_t scan_interval, uint32_t scan_window, tBLE_ADDR_TYPE addr_type,
            tBTM_BLE_DISCARD_RULE discard_rule, tBTM_BLE_REF_VALUE ref_value)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
    BTM_TRACE_EVENT (" BTM_BleEnableBatchScan: %d, %d, %d, %d, %d, %d",
        scan_mode, scan_interval, scan_window, addr_type, discard_rule, ref_value);
@@ -761,9 +699,7 @@ tBTM_STATUS BTM_BleEnableBatchScan(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
            BTM_BLE_SCAN_DISABLED_STATE == ble_batchscan_cb.cur_state ||
            BTM_BLE_SCAN_DISABLE_CALLED == ble_batchscan_cb.cur_state)
        {
            status = btm_ble_enable_disable_batchscan(true);
            if (BTM_CMD_STARTED != status)
               return status;
            btm_ble_enable_disable_batchscan(true);
            btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_ENB_DISAB_CUST_FEATURE,
                                       BTM_BLE_SCAN_ENABLE_CALLED, 0, ref_value);
        }
@@ -774,10 +710,8 @@ tBTM_STATUS BTM_BleEnableBatchScan(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
        ble_batchscan_cb.addr_type = addr_type;
        ble_batchscan_cb.discard_rule = discard_rule;
        /* This command starts batch scanning, if enabled */
        status = btm_ble_set_batchscan_param(scan_mode, scan_interval, scan_window, addr_type,
        btm_ble_set_batchscan_param(scan_mode, scan_interval, scan_window, addr_type,
                    discard_rule);
        if (BTM_CMD_STARTED != status)
            return status;

        /* The user needs to be provided scan enable event */
        btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_PARAMS, ble_batchscan_cb.cur_state,
@@ -788,7 +722,7 @@ tBTM_STATUS BTM_BleEnableBatchScan(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
        BTM_TRACE_ERROR("Illegal enable scan params");
        return BTM_ILLEGAL_VALUE;
    }
    return status;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -799,12 +733,9 @@ tBTM_STATUS BTM_BleEnableBatchScan(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
**
** Parameters:      ref_value - Reference value
**
** Returns          tBTM_STATUS
**
*******************************************************************************/
tBTM_STATUS BTM_BleDisableBatchScan(tBTM_BLE_REF_VALUE ref_value)
{
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
    BTM_TRACE_EVENT (" BTM_BleDisableBatchScan");

@@ -819,16 +750,12 @@ tBTM_STATUS BTM_BleDisableBatchScan(tBTM_BLE_REF_VALUE ref_value)
        return BTM_ERR_PROCESSING;
    }

    status = btm_ble_enable_disable_batchscan(false);
    if (BTM_CMD_STARTED == status)
    {
    btm_ble_enable_disable_batchscan(false);
    /* The user needs to be provided scan disable event */
    btm_ble_batchscan_enq_op_q(BTM_BLE_BATCH_SCAN_SET_PARAMS,
                               BTM_BLE_SCAN_DISABLE_CALLED, BTM_BLE_BATCH_SCAN_DISABLE_EVT,
                               ref_value);
    }

    return status;
    return BTM_CMD_STARTED;
}

/*******************************************************************************
@@ -849,8 +776,6 @@ tBTM_STATUS BTM_BleReadScanReports(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
    tBTM_STATUS     status = BTM_NO_RESOURCES;
    tBTM_BLE_VSC_CB cmn_ble_vsc_cb;
    uint8_t read_scan_mode = 0;
    uint8_t *p_data = NULL, num_records = 0;
    uint16_t data_len = 0;

    BTM_TRACE_EVENT (" BTM_BleReadScanReports; %d, %d", scan_mode, ref_value);

@@ -877,12 +802,8 @@ tBTM_STATUS BTM_BleReadScanReports(tBTM_BLE_BATCH_SCAN_MODE scan_mode,
        status = btm_ble_batchscan_enq_rep_q(scan_mode, ref_value);
        if (BTM_SUCCESS == status)
        {
            status = btm_ble_read_batchscan_reports(scan_mode, ref_value);
            if (BTM_CMD_STARTED != status)
            {
                btm_ble_batchscan_deq_rep_data(scan_mode, &ref_value,
                                               &num_records, &p_data, &data_len);
            }
            btm_ble_read_batchscan_reports(scan_mode, ref_value);
            status = BTM_CMD_STARTED;
        }
    }
    else
+5 −8
Original line number Diff line number Diff line
@@ -469,14 +469,11 @@ bool btm_ble_start_select_conn(bool start, tBTM_BLE_SEL_CBACK *p_select_cb
            }
            else
            {
                if (!btm_ble_send_extended_scan_params(BTM_BLE_SCAN_MODE_PASS,
                btm_ble_send_extended_scan_params(BTM_BLE_SCAN_MODE_PASS,
                                                  scan_int,
                                                  scan_win,
                                                  p_cb->addr_mgnt_cb.own_addr_type,
                                                       SP_ADV_WL))
                {
                    return false;
                }
                                                  SP_ADV_WL);
            }

            if (!btm_ble_topology_check(BTM_BLE_STATE_PASSIVE_SCAN))
+3 −9
Original line number Diff line number Diff line
@@ -83,7 +83,6 @@ void btm_ble_cont_energy_cmpl_cback (tBTM_VSC_CMPL *p_params)
*******************************************************************************/
tBTM_STATUS BTM_BleGetEnergyInfo(tBTM_BLE_ENERGY_INFO_CBACK *p_ener_cback)
{
    tBTM_STATUS status = BTM_ILLEGAL_VALUE;
    tBTM_BLE_VSC_CB cmn_ble_vsc_cb;

    BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb);
@@ -97,14 +96,9 @@ tBTM_STATUS BTM_BleGetEnergyInfo(tBTM_BLE_ENERGY_INFO_CBACK *p_ener_cback)
    }

    ble_energy_info_cb.p_ener_cback = p_ener_cback;
    if ((status = BTM_VendorSpecificCommand (HCI_BLE_ENERGY_INFO_OCF, 0, NULL,
                   btm_ble_cont_energy_cmpl_cback)) != BTM_CMD_STARTED)
    {
        BTM_TRACE_ERROR("BTM_BleGetEnergyInfo status: %d", status);
        return BTM_ILLEGAL_VALUE;
    }

    return status;
    BTM_VendorSpecificCommand(HCI_BLE_ENERGY_INFO_OCF, 0, NULL,
                              btm_ble_cont_energy_cmpl_cback);
    return BTM_CMD_STARTED;
}

#endif
+5 −18

File changed.

Preview size limit exceeded, changes collapsed.

Loading