提交 cba6b758 编写于 作者: L Luiz Augusto von Dentz 提交者: Marcel Holtmann

Bluetooth: hci_sync: Make use of hci_cmd_sync_queue set 2

This make use of hci_cmd_sync_queue for the following MGMT commands:

Add Advertising
Remove Advertising
Add Extended Advertising Parameters
Add Extended Advertising Data

mgmt-tester -s "Add Advertising"

Test Summary
------------
Add Advertising - Failure: LE off                    Passed
Add Advertising - Invalid Params 1 (AD too long)     Passed
Add Advertising - Invalid Params 2 (Malformed len)   Passed
Add Advertising - Invalid Params 3 (Malformed len)   Passed
Add Advertising - Invalid Params 4 (Malformed len)   Passed
Add Advertising - Invalid Params 5 (AD too long)     Passed
Add Advertising - Invalid Params 6 (ScRsp too long)  Passed
Add Advertising - Invalid Params 7 (Malformed len)   Passed
Add Advertising - Invalid Params 8 (Malformed len)   Passed
Add Advertising - Invalid Params 9 (Malformed len)   Passed
Add Advertising - Invalid Params 10 (ScRsp too long) Passed
Add Advertising - Rejected (Timeout, !Powered)       Passed
Add Advertising - Success 1 (Powered, Add Adv Inst)  Passed
Add Advertising - Success 2 (!Powered, Add Adv Inst) Passed
Add Advertising - Success 3 (!Powered, Adv Enable)   Passed
Add Advertising - Success 4 (Set Adv on override)    Passed
Add Advertising - Success 5 (Set Adv off override)   Passed
Add Advertising - Success 6 (Scan Rsp Dta, Adv ok)   Passed
Add Advertising - Success 7 (Scan Rsp Dta, Scan ok)  Passed
Add Advertising - Success 8 (Connectable Flag)       Passed
Add Advertising - Success 9 (General Discov Flag)    Passed
Add Advertising - Success 10 (Limited Discov Flag)   Passed
Add Advertising - Success 11 (Managed Flags)         Passed
Add Advertising - Success 12 (TX Power Flag)         Passed
Add Advertising - Success 13 (ADV_SCAN_IND)          Passed
Add Advertising - Success 14 (ADV_NONCONN_IND)       Passed
Add Advertising - Success 15 (ADV_IND)               Passed
Add Advertising - Success 16 (Connectable -> on)     Passed
Add Advertising - Success 17 (Connectable -> off)    Passed
Add Advertising - Success 18 (Power -> off, Remove)  Passed
Add Advertising - Success 19 (Power -> off, Keep)    Passed
Add Advertising - Success 20 (Add Adv override)      Passed
Add Advertising - Success 21 (Timeout expires)       Passed
Add Advertising - Success 22 (LE -> off, Remove)     Passed
Add Advertising - Success (Empty ScRsp)              Passed
Add Advertising - Success (ScRsp only)               Passed
Add Advertising - Invalid Params (ScRsp too long)    Passed
Add Advertising - Success (ScRsp appear)             Passed
Add Advertising - Invalid Params (ScRsp appear long) Passed
Add Advertising - Success (Appear is null)           Passed
Add Advertising - Success (Name is null)             Passed
Add Advertising - Success (Complete name)            Passed
Add Advertising - Success (Shortened name)           Passed
Add Advertising - Success (Short name)               Passed
Add Advertising - Success (Name + data)              Passed
Add Advertising - Invalid Params (Name + data)       Passed
Add Advertising - Success (Name+data+appear)         Passed
Total: 47, Passed: 47 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 2.17 seconds

mgmt-tester -s "Remove Advertising"

Test Summary
------------
Remove Advertising - Invalid Params 1                Passed
Remove Advertising - Success 1                       Passed
Remove Advertising - Success 2                       Passed
Total: 3, Passed: 3 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 0.0585 seconds

mgmt-tester -s "Ext Adv MGMT Params"

Test Summary:
------------
Ext Adv MGMT Params - Unpowered                      Passed
Ext Adv MGMT Params - Invalid parameters             Passed
Ext Adv MGMT Params - Success                        Passed
Ext Adv MGMT Params - (5.0) Success                  Passed
Total: 4, Passed: 4 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 0.0746 seconds

mgmt-tester -s "Ext Adv MGMT -"

Test Summary
------------
Ext Adv MGMT - Data set without Params               Passed
Ext Adv MGMT - AD Data (5.0) Invalid parameters      Passed
Ext Adv MGMT - AD Data (5.0) Success                 Passed
Ext Adv MGMT - AD Scan Response (5.0) Success        Passed
Total: 4, Passed: 4 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 0.0805 seconds
Signed-off-by: NLuiz Augusto von Dentz <luiz.von.dentz@intel.com>
Signed-off-by: NMarcel Holtmann <marcel@holtmann.org>
上级 161510cc
......@@ -380,6 +380,7 @@ typedef void (*hci_req_complete_skb_t)(struct hci_dev *hdev, u8 status,
#define HCI_REQ_SKB BIT(1)
struct hci_ctrl {
struct sock *sk;
u16 opcode;
u8 req_flags;
u8 req_event;
......@@ -405,6 +406,7 @@ struct bt_skb_cb {
#define hci_skb_pkt_type(skb) bt_cb((skb))->pkt_type
#define hci_skb_expect(skb) bt_cb((skb))->expect
#define hci_skb_opcode(skb) bt_cb((skb))->hci.opcode
#define hci_skb_sk(skb) bt_cb((skb))->hci.sk
static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how)
{
......
......@@ -43,3 +43,23 @@ int hci_cmd_sync_queue(struct hci_dev *hdev, hci_cmd_sync_work_func_t func,
int hci_update_eir_sync(struct hci_dev *hdev);
int hci_update_class_sync(struct hci_dev *hdev);
int hci_update_eir_sync(struct hci_dev *hdev);
int hci_update_class_sync(struct hci_dev *hdev);
int hci_update_random_address_sync(struct hci_dev *hdev, bool require_privacy,
bool rpa, u8 *own_addr_type);
int hci_update_scan_rsp_data_sync(struct hci_dev *hdev, u8 instance);
int hci_update_adv_data_sync(struct hci_dev *hdev, u8 instance);
int hci_schedule_adv_instance_sync(struct hci_dev *hdev, u8 instance,
bool force);
int hci_setup_ext_adv_instance_sync(struct hci_dev *hdev, u8 instance);
int hci_start_ext_adv_sync(struct hci_dev *hdev, u8 instance);
int hci_enable_ext_advertising_sync(struct hci_dev *hdev, u8 instance);
int hci_enable_advertising_sync(struct hci_dev *hdev);
int hci_remove_advertising_sync(struct hci_dev *hdev, struct sock *sk,
u8 instance, bool force);
int hci_disable_advertising_sync(struct hci_dev *hdev);
......@@ -1239,6 +1239,55 @@ static void hci_cc_le_set_adv_set_random_addr(struct hci_dev *hdev,
hci_dev_unlock(hdev);
}
static void hci_cc_le_remove_adv_set(struct hci_dev *hdev, struct sk_buff *skb)
{
__u8 status = *((__u8 *)skb->data);
u8 *instance;
int err;
if (status)
return;
instance = hci_sent_cmd_data(hdev, HCI_OP_LE_REMOVE_ADV_SET);
if (!instance)
return;
hci_dev_lock(hdev);
err = hci_remove_adv_instance(hdev, *instance);
if (!err)
mgmt_advertising_removed(hci_skb_sk(hdev->sent_cmd), hdev,
*instance);
hci_dev_unlock(hdev);
}
static void hci_cc_le_clear_adv_sets(struct hci_dev *hdev, struct sk_buff *skb)
{
__u8 status = *((__u8 *)skb->data);
struct adv_info *adv, *n;
int err;
if (status)
return;
if (!hci_sent_cmd_data(hdev, HCI_OP_LE_CLEAR_ADV_SETS))
return;
hci_dev_lock(hdev);
list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {
u8 instance = adv->instance;
err = hci_remove_adv_instance(hdev, instance);
if (!err)
mgmt_advertising_removed(hci_skb_sk(hdev->sent_cmd),
hdev, instance);
}
hci_dev_unlock(hdev);
}
static void hci_cc_le_read_transmit_power(struct hci_dev *hdev,
struct sk_buff *skb)
{
......@@ -3725,6 +3774,14 @@ static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb,
hci_cc_le_set_adv_set_random_addr(hdev, skb);
break;
case HCI_OP_LE_REMOVE_ADV_SET:
hci_cc_le_remove_adv_set(hdev, skb);
break;
case HCI_OP_LE_CLEAR_ADV_SETS:
hci_cc_le_clear_adv_sets(hdev, skb);
break;
case HCI_OP_LE_READ_TRANSMIT_POWER:
hci_cc_le_read_transmit_power(hdev, skb);
break;
......
此差异已折叠。
......@@ -999,11 +999,22 @@ static void service_cache_off(struct work_struct *work)
hci_cmd_sync_queue(hdev, service_cache_sync, NULL, NULL);
}
static int rpa_expired_sync(struct hci_dev *hdev, void *data)
{
/* The generation of a new RPA and programming it into the
* controller happens in the hci_req_enable_advertising()
* function.
*/
if (ext_adv_capable(hdev))
return hci_start_ext_adv_sync(hdev, hdev->cur_adv_instance);
else
return hci_enable_advertising_sync(hdev);
}
static void rpa_expired(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev,
rpa_expired.work);
struct hci_request req;
bt_dev_dbg(hdev, "");
......@@ -1012,16 +1023,7 @@ static void rpa_expired(struct work_struct *work)
if (!hci_dev_test_flag(hdev, HCI_ADVERTISING))
return;
/* The generation of a new RPA and programming it into the
* controller happens in the hci_req_enable_advertising()
* function.
*/
hci_req_init(&req, hdev);
if (ext_adv_capable(hdev))
__hci_req_start_ext_adv(&req, hdev->cur_adv_instance);
else
__hci_req_enable_advertising(&req);
hci_req_run(&req, NULL);
hci_cmd_sync_queue(hdev, rpa_expired_sync, NULL, NULL);
}
static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
......@@ -7873,58 +7875,66 @@ static bool adv_busy(struct hci_dev *hdev)
pending_find(MGMT_OP_ADD_EXT_ADV_DATA, hdev));
}
static void add_advertising_complete(struct hci_dev *hdev, u8 status,
u16 opcode)
static void add_adv_complete(struct hci_dev *hdev, struct sock *sk, u8 instance,
int err)
{
struct mgmt_pending_cmd *cmd;
struct mgmt_cp_add_advertising *cp;
struct mgmt_rp_add_advertising rp;
struct adv_info *adv_instance, *n;
u8 instance;
struct adv_info *adv, *n;
bt_dev_dbg(hdev, "status %u", status);
bt_dev_dbg(hdev, "err %d", err);
hci_dev_lock(hdev);
cmd = pending_find(MGMT_OP_ADD_ADVERTISING, hdev);
if (!cmd)
cmd = pending_find(MGMT_OP_ADD_EXT_ADV_DATA, hdev);
list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {
u8 instance;
list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) {
if (!adv_instance->pending)
if (!adv->pending)
continue;
if (!status) {
adv_instance->pending = false;
if (!err) {
adv->pending = false;
continue;
}
instance = adv_instance->instance;
instance = adv->instance;
if (hdev->cur_adv_instance == instance)
cancel_adv_timeout(hdev);
hci_remove_adv_instance(hdev, instance);
mgmt_advertising_removed(cmd ? cmd->sk : NULL, hdev, instance);
mgmt_advertising_removed(sk, hdev, instance);
}
if (!cmd)
goto unlock;
hci_dev_unlock(hdev);
}
static void add_advertising_complete(struct hci_dev *hdev, void *data, int err)
{
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_add_advertising *cp = cmd->param;
struct mgmt_rp_add_advertising rp;
memset(&rp, 0, sizeof(rp));
cp = cmd->param;
rp.instance = cp->instance;
if (status)
if (err)
mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(status));
mgmt_status(err));
else
mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(status), &rp, sizeof(rp));
mgmt_status(err), &rp, sizeof(rp));
mgmt_pending_remove(cmd);
add_adv_complete(hdev, cmd->sk, cp->instance, err);
unlock:
hci_dev_unlock(hdev);
mgmt_pending_free(cmd);
}
static int add_advertising_sync(struct hci_dev *hdev, void *data)
{
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_add_advertising *cp = cmd->param;
return hci_schedule_adv_instance_sync(hdev, cp->instance, true);
}
static int add_advertising(struct sock *sk, struct hci_dev *hdev,
......@@ -7940,7 +7950,6 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev,
struct adv_info *next_instance;
int err;
struct mgmt_pending_cmd *cmd;
struct hci_request req;
bt_dev_dbg(hdev, "sock %p", sk);
......@@ -8048,25 +8057,19 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev,
/* We're good to go, update advertising data, parameters, and start
* advertising.
*/
cmd = mgmt_pending_add(sk, MGMT_OP_ADD_ADVERTISING, hdev, data,
cmd = mgmt_pending_new(sk, MGMT_OP_ADD_ADVERTISING, hdev, data,
data_len);
if (!cmd) {
err = -ENOMEM;
goto unlock;
}
hci_req_init(&req, hdev);
err = __hci_req_schedule_adv_instance(&req, schedule_instance, true);
if (!err)
err = hci_req_run(&req, add_advertising_complete);
cp->instance = schedule_instance;
if (err < 0) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
MGMT_STATUS_FAILED);
mgmt_pending_remove(cmd);
}
err = hci_cmd_sync_queue(hdev, add_advertising_sync, cmd,
add_advertising_complete);
if (err < 0)
mgmt_pending_free(cmd);
unlock:
hci_dev_unlock(hdev);
......@@ -8074,30 +8077,25 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev,
return err;
}
static void add_ext_adv_params_complete(struct hci_dev *hdev, u8 status,
u16 opcode)
static void add_ext_adv_params_complete(struct hci_dev *hdev, void *data,
int err)
{
struct mgmt_pending_cmd *cmd;
struct mgmt_cp_add_ext_adv_params *cp;
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_add_ext_adv_params *cp = cmd->param;
struct mgmt_rp_add_ext_adv_params rp;
struct adv_info *adv_instance;
struct adv_info *adv;
u32 flags;
BT_DBG("%s", hdev->name);
hci_dev_lock(hdev);
cmd = pending_find(MGMT_OP_ADD_EXT_ADV_PARAMS, hdev);
if (!cmd)
goto unlock;
cp = cmd->param;
adv_instance = hci_find_adv_instance(hdev, cp->instance);
if (!adv_instance)
adv = hci_find_adv_instance(hdev, cp->instance);
if (!adv)
goto unlock;
rp.instance = cp->instance;
rp.tx_power = adv_instance->tx_power;
rp.tx_power = adv->tx_power;
/* While we're at it, inform userspace of the available space for this
* advertisement, given the flags that will be used.
......@@ -8106,39 +8104,44 @@ static void add_ext_adv_params_complete(struct hci_dev *hdev, u8 status,
rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
if (status) {
if (err) {
/* If this advertisement was previously advertising and we
* failed to update it, we signal that it has been removed and
* delete its structure
*/
if (!adv_instance->pending)
if (!adv->pending)
mgmt_advertising_removed(cmd->sk, hdev, cp->instance);
hci_remove_adv_instance(hdev, cp->instance);
mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(status));
mgmt_status(err));
} else {
mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(status), &rp, sizeof(rp));
mgmt_status(err), &rp, sizeof(rp));
}
unlock:
if (cmd)
mgmt_pending_remove(cmd);
mgmt_pending_free(cmd);
hci_dev_unlock(hdev);
}
static int add_ext_adv_params_sync(struct hci_dev *hdev, void *data)
{
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_add_ext_adv_params *cp = cmd->param;
return hci_setup_ext_adv_instance_sync(hdev, cp->instance);
}
static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev,
void *data, u16 data_len)
{
struct mgmt_cp_add_ext_adv_params *cp = data;
struct mgmt_rp_add_ext_adv_params rp;
struct mgmt_pending_cmd *cmd = NULL;
struct adv_info *adv_instance;
struct hci_request req;
u32 flags, min_interval, max_interval;
u16 timeout, duration;
u8 status;
......@@ -8220,29 +8223,18 @@ static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev,
/* Submit request for advertising params if ext adv available */
if (ext_adv_capable(hdev)) {
hci_req_init(&req, hdev);
adv_instance = hci_find_adv_instance(hdev, cp->instance);
/* Updating parameters of an active instance will return a
* Command Disallowed error, so we must first disable the
* instance if it is active.
*/
if (!adv_instance->pending)
__hci_req_disable_ext_adv_instance(&req, cp->instance);
__hci_req_setup_ext_adv_instance(&req, cp->instance);
err = hci_req_run(&req, add_ext_adv_params_complete);
if (!err)
cmd = mgmt_pending_add(sk, MGMT_OP_ADD_EXT_ADV_PARAMS,
hdev, data, data_len);
cmd = mgmt_pending_new(sk, MGMT_OP_ADD_EXT_ADV_PARAMS, hdev,
data, data_len);
if (!cmd) {
err = -ENOMEM;
hci_remove_adv_instance(hdev, cp->instance);
goto unlock;
}
err = hci_cmd_sync_queue(hdev, add_ext_adv_params_sync, cmd,
add_ext_adv_params_complete);
if (err < 0)
mgmt_pending_free(cmd);
} else {
rp.instance = cp->instance;
rp.tx_power = HCI_ADV_TX_POWER_NO_PREFERENCE;
......@@ -8259,6 +8251,49 @@ static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev,
return err;
}
static void add_ext_adv_data_complete(struct hci_dev *hdev, void *data, int err)
{
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_add_ext_adv_data *cp = cmd->param;
struct mgmt_rp_add_advertising rp;
add_adv_complete(hdev, cmd->sk, cp->instance, err);
memset(&rp, 0, sizeof(rp));
rp.instance = cp->instance;
if (err)
mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(err));
else
mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(err), &rp, sizeof(rp));
mgmt_pending_free(cmd);
}
static int add_ext_adv_data_sync(struct hci_dev *hdev, void *data)
{
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_add_ext_adv_data *cp = cmd->param;
int err;
if (ext_adv_capable(hdev)) {
err = hci_update_adv_data_sync(hdev, cp->instance);
if (err)
return err;
err = hci_update_scan_rsp_data_sync(hdev, cp->instance);
if (err)
return err;
return hci_enable_ext_advertising_sync(hdev, cp->instance);
}
return hci_schedule_adv_instance_sync(hdev, cp->instance, true);
}
static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,
u16 data_len)
{
......@@ -8269,7 +8304,6 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,
struct adv_info *adv_instance;
int err = 0;
struct mgmt_pending_cmd *cmd;
struct hci_request req;
BT_DBG("%s", hdev->name);
......@@ -8311,78 +8345,52 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,
cp->data, cp->scan_rsp_len,
cp->data + cp->adv_data_len);
/* We're good to go, update advertising data, parameters, and start
* advertising.
*/
hci_req_init(&req, hdev);
hci_req_add(&req, HCI_OP_READ_LOCAL_NAME, 0, NULL);
if (ext_adv_capable(hdev)) {
__hci_req_update_adv_data(&req, cp->instance);
__hci_req_update_scan_rsp_data(&req, cp->instance);
__hci_req_enable_ext_advertising(&req, cp->instance);
} else {
/* If using software rotation, determine next instance to use */
if (hdev->cur_adv_instance == cp->instance) {
/* If the currently advertised instance is being changed
* then cancel the current advertising and schedule the
* next instance. If there is only one instance then the
* overridden advertising data will be visible right
* away
*/
cancel_adv_timeout(hdev);
next_instance = hci_get_next_instance(hdev,
cp->instance);
if (next_instance)
schedule_instance = next_instance->instance;
} else if (!hdev->adv_instance_timeout) {
/* Immediately advertise the new instance if no other
* instance is currently being advertised.
*/
schedule_instance = cp->instance;
}
/* If using software rotation, determine next instance to use */
if (hdev->cur_adv_instance == cp->instance) {
/* If the currently advertised instance is being changed
* then cancel the current advertising and schedule the
* next instance. If there is only one instance then the
* overridden advertising data will be visible right
* away
*/
cancel_adv_timeout(hdev);
/* If the HCI_ADVERTISING flag is set or there is no instance to
* be advertised then we have no HCI communication to make.
* Simply return.
next_instance = hci_get_next_instance(hdev, cp->instance);
if (next_instance)
schedule_instance = next_instance->instance;
} else if (!hdev->adv_instance_timeout) {
/* Immediately advertise the new instance if no other
* instance is currently being advertised.
*/
if (hci_dev_test_flag(hdev, HCI_ADVERTISING) ||
!schedule_instance) {
if (adv_instance->pending) {
mgmt_advertising_added(sk, hdev, cp->instance);
adv_instance->pending = false;
}
rp.instance = cp->instance;
err = mgmt_cmd_complete(sk, hdev->id,
MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_SUCCESS, &rp,
sizeof(rp));
goto unlock;
}
schedule_instance = cp->instance;
}
err = __hci_req_schedule_adv_instance(&req, schedule_instance,
true);
/* If the HCI_ADVERTISING flag is set or there is no instance to
* be advertised then we have no HCI communication to make.
* Simply return.
*/
if (hci_dev_test_flag(hdev, HCI_ADVERTISING) || !schedule_instance) {
if (adv_instance->pending) {
mgmt_advertising_added(sk, hdev, cp->instance);
adv_instance->pending = false;
}
rp.instance = cp->instance;
err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
goto unlock;
}
cmd = mgmt_pending_add(sk, MGMT_OP_ADD_EXT_ADV_DATA, hdev, data,
cmd = mgmt_pending_new(sk, MGMT_OP_ADD_EXT_ADV_DATA, hdev, data,
data_len);
if (!cmd) {
err = -ENOMEM;
goto clear_new_instance;
}
if (!err)
err = hci_req_run(&req, add_advertising_complete);
err = hci_cmd_sync_queue(hdev, add_ext_adv_data_sync, cmd,
add_ext_adv_data_complete);
if (err < 0) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_FAILED);
mgmt_pending_remove(cmd);
mgmt_pending_free(cmd);
goto clear_new_instance;
}
......@@ -8405,43 +8413,49 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,
return err;
}
static void remove_advertising_complete(struct hci_dev *hdev, u8 status,
u16 opcode)
static void remove_advertising_complete(struct hci_dev *hdev, void *data,
int err)
{
struct mgmt_pending_cmd *cmd;
struct mgmt_cp_remove_advertising *cp;
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_remove_advertising *cp = cmd->param;
struct mgmt_rp_remove_advertising rp;
bt_dev_dbg(hdev, "status %u", status);
bt_dev_dbg(hdev, "err %d", err);
hci_dev_lock(hdev);
memset(&rp, 0, sizeof(rp));
rp.instance = cp->instance;
/* A failure status here only means that we failed to disable
* advertising. Otherwise, the advertising instance has been removed,
* so report success.
*/
cmd = pending_find(MGMT_OP_REMOVE_ADVERTISING, hdev);
if (!cmd)
goto unlock;
if (err)
mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(err));
else
mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,
MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
cp = cmd->param;
rp.instance = cp->instance;
mgmt_pending_free(cmd);
}
mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode, MGMT_STATUS_SUCCESS,
&rp, sizeof(rp));
mgmt_pending_remove(cmd);
static int remove_advertising_sync(struct hci_dev *hdev, void *data)
{
struct mgmt_pending_cmd *cmd = data;
struct mgmt_cp_remove_advertising *cp = cmd->param;
int err;
unlock:
hci_dev_unlock(hdev);
err = hci_remove_advertising_sync(hdev, cmd->sk, cp->instance, true);
if (err)
return err;
if (list_empty(&hdev->adv_instances))
err = hci_disable_advertising_sync(hdev);
return err;
}
static int remove_advertising(struct sock *sk, struct hci_dev *hdev,
void *data, u16 data_len)
{
struct mgmt_cp_remove_advertising *cp = data;
struct mgmt_rp_remove_advertising rp;
struct mgmt_pending_cmd *cmd;
struct hci_request req;
int err;
bt_dev_dbg(hdev, "sock %p", sk);
......@@ -8476,44 +8490,17 @@ static int remove_advertising(struct sock *sk, struct hci_dev *hdev,
goto unlock;
}
hci_req_init(&req, hdev);
/* If we use extended advertising, instance is disabled and removed */
if (ext_adv_capable(hdev)) {
__hci_req_disable_ext_adv_instance(&req, cp->instance);
__hci_req_remove_ext_adv_instance(&req, cp->instance);
}
hci_req_clear_adv_instance(hdev, sk, &req, cp->instance, true);
if (list_empty(&hdev->adv_instances))
__hci_req_disable_advertising(&req);
/* If no HCI commands have been collected so far or the HCI_ADVERTISING
* flag is set or the device isn't powered then we have no HCI
* communication to make. Simply return.
*/
if (skb_queue_empty(&req.cmd_q) ||
!hdev_is_powered(hdev) ||
hci_dev_test_flag(hdev, HCI_ADVERTISING)) {
hci_req_purge(&req);
rp.instance = cp->instance;
err = mgmt_cmd_complete(sk, hdev->id,
MGMT_OP_REMOVE_ADVERTISING,
MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
goto unlock;
}
cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_ADVERTISING, hdev, data,
cmd = mgmt_pending_new(sk, MGMT_OP_REMOVE_ADVERTISING, hdev, data,
data_len);
if (!cmd) {
err = -ENOMEM;
goto unlock;
}
err = hci_req_run(&req, remove_advertising_complete);
err = hci_cmd_sync_queue(hdev, remove_advertising_sync, cmd,
remove_advertising_complete);
if (err < 0)
mgmt_pending_remove(cmd);
mgmt_pending_free(cmd);
unlock:
hci_dev_unlock(hdev);
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册