int bt_le_adv_start(const struct bt_le_adv_param *param,
const struct bt_data *ad, size_t ad_len,
const struct bt_data *sd, size_t sd_len)
{
struct nble_gap_set_adv_params_req params = { 0 };
struct nble_gap_set_adv_data_req data = { 0 };
int err;
if (!valid_adv_param(param)) {
return -EINVAL;
}
err = set_ad(&data.ad, ad, ad_len);
if (err) {
BT_ERR("Error setting ad data %d", err);
return err;
}
err = set_ad(&data.sd, sd, sd_len);
if (err) {
BT_ERR("Error setting scan response data %d", err);
return err;
}
/* Set advertising data */
nble_gap_set_adv_data_req(&data);
/* TODO: Timeout is handled by application timer */
params.timeout = 0;
/* forced to none currently (no whitelist support) */
params.filter_policy = 0;
params.interval_max = param->interval_max;
params.interval_min = param->interval_min;
if (param->options & BT_LE_ADV_OPT_CONNECTABLE) {
params.type = BT_LE_ADV_IND;
} else {
if (sd) {
params.type = BT_LE_ADV_SCAN_IND;
} else {
params.type = BT_LE_ADV_NONCONN_IND;
}
}
/* Set advertising parameters */
nble_gap_set_adv_params_req(¶ms);
/* Start advertising */
nble_gap_start_adv_req();
return 0;
}
int bt_le_adv_start(const struct bt_le_adv_param *param,
const struct bt_data *ad, size_t ad_len,
const struct bt_data *sd, size_t sd_len)
{
struct ble_gap_adv_params params = { 0 };
int i;
if (!valid_adv_param(param)) {
return -EINVAL;
}
for (i = 0; i < ad_len; i++) {
uint8_t *p;
/* Check if ad fit in the remaining buffer */
if (params.ad.len + ad[i].data_len + 2 > 31) {
break;
}
p = ¶ms.ad.data[params.ad.len];
*p++ = ad[i].data_len + 1;
*p++ = ad[i].type;
memcpy(p, ad[i].data, ad[i].data_len);
params.ad.len += ad[i].data_len + 2;
}
/*
* Don't bother with scan response if the advertising type isn't
* a scannable one.
*/
if (param->type != BT_LE_ADV_IND && param->type != BT_LE_ADV_SCAN_IND) {
goto send_set_param;
}
for (i = 0; i < sd_len; i++) {
uint8_t *p;
/* Check if sd fit in the remaining buffer */
if (params.sd.len + sd[i].data_len + 2 > 31) {
break;
}
p = ¶ms.sd.data[params.sd.len];
*p++ = sd[i].data_len + 1;
*p++ = sd[i].type;
memcpy(p, sd[i].data, sd[i].data_len);
params.sd.len += sd[i].data_len + 2;
}
send_set_param:
/* Timeout is handled by application timer */
params.timeout = 0;
/* forced to none currently (no whitelist support) */
params.filter_policy = 0;
params.interval_max = param->interval_max;
params.interval_min = param->interval_min;
params.type = param->type;
ble_gap_start_advertise_req(¶ms);
return 0;
}
int bt_le_adv_start(const struct bt_le_adv_param *param,
const struct bt_data *ad, size_t ad_len,
const struct bt_data *sd, size_t sd_len)
{
int err;
struct nble_gap_adv_params set_param = {0};
struct nble_gap_ad_data_params data;
if (!valid_adv_param(param)) {
return -EINVAL;
}
memset(&data, 0, sizeof(data));
if (atomic_test_bit(bt_dev.flags, BT_DEV_KEEP_ADVERTISING)) {
return -EALREADY;
}
err = set_advertise_disable();
if (err) {
return err;
}
err = set_ad(&data.ad, ad, ad_len);
if (err) {
return err;
}
/*
* Don't bother with scan response if the advertising type isn't
* a scannable one.
*/
if (param->type == BT_LE_ADV_IND || param->type == BT_LE_ADV_SCAN_IND) {
err = set_ad(&data.sd, sd, sd_len);
if (err) {
return err;
}
}
nble_gap_set_adv_data_req(&data);
/* Timeout is handled by application timer */
set_param.timeout = 0;
/* forced to none currently (no whitelist support) */
set_param.filter_policy = 0;
set_param.interval_max = param->interval_max;
set_param.interval_min = param->interval_min;
set_param.type = param->type;
nble_gap_set_adv_params_req(&set_param);
#if 0
if (param->addr_type == BT_LE_ADV_ADDR_NRPA) {
err = le_set_nrpa();
if (err) {
net_buf_unref(buf);
return err;
}
set_param->own_addr_type = BT_ADDR_LE_RANDOM;
} else {
set_param->own_addr_type = BT_ADDR_LE_PUBLIC;
}
bt_hci_cmd_send(BT_HCI_OP_LE_SET_ADV_PARAMETERS, buf);
#endif
err = set_advertise_enable();
if (err) {
return err;
}
atomic_set_bit(bt_dev.flags, BT_DEV_KEEP_ADVERTISING);
return 0;
}
