static void start_advertising(const uint8_t *data, uint16_t len)
{
const struct gap_start_advertising_cmd *cmd = (void *) data;
struct gap_start_advertising_rp rp;
uint8_t adv_len, sd_len;
bool adv_conn;
int i;
for (i = 0, adv_len = 1; i < cmd->adv_data_len; adv_len++) {
if (adv_len >= ARRAY_SIZE(ad)) {
BTTESTER_DBG("ad[] Out of memory");
goto fail;
}
ad[adv_len].type = cmd->adv_data[i++];
ad[adv_len].data_len = cmd->adv_data[i++];
ad[adv_len].data = &cmd->adv_data[i];
i += ad[adv_len].data_len;
}
for (i = 0, sd_len = 0; i < cmd->scan_rsp_len; sd_len++) {
if (sd_len >= ARRAY_SIZE(sd)) {
BTTESTER_DBG("sd[] Out of memory");
goto fail;
}
sd[sd_len].type = cmd->scan_rsp[i++];
sd[sd_len].data_len = cmd->scan_rsp[i++];
sd[sd_len].data = &cmd->scan_rsp[i];
i += sd[sd_len].data_len;
}
adv_conn = atomic_test_bit(¤t_settings, GAP_SETTINGS_CONNECTABLE);
/* BTP API don't allow to set empty scan response data. */
if (bt_le_adv_start(adv_conn ? BT_LE_ADV_CONN : BT_LE_ADV_NCONN,
ad, adv_len, sd_len ? sd : NULL, sd_len) < 0) {
BTTESTER_DBG("Failed to start advertising");
goto fail;
}
atomic_set_bit(¤t_settings, GAP_SETTINGS_ADVERTISING);
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
return;
fail:
tester_rsp(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
BTP_STATUS_FAILED);
}
static void bt_ready(int err)
{
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
bt_gatt_register(attrs, ARRAY_SIZE(attrs));
err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad),
sd, ARRAY_SIZE(sd));
if (err) {
printk("Advertising failed to start (err %d)\n", err);
return;
}
}
static void start_advertising(const uint8_t *data, uint16_t len)
{
const struct gap_start_advertising_cmd *cmd = (void *) data;
struct gap_start_advertising_rp rp;
uint8_t adv_type, adv_len;
int i;
if (atomic_test_bit(¤t_settings, GAP_SETTINGS_CONNECTABLE)) {
adv_type = BT_LE_ADV_IND;
} else {
adv_type = BT_LE_ADV_NONCONN_IND;
}
for (i = 0, adv_len = 1; i < cmd->adv_data_len; adv_len++) {
if (adv_len >= ARRAY_SIZE(ad)) {
BTTESTER_DBG("ad[] Out of memory");
goto fail;
}
ad[adv_len].type = cmd->adv_data[i++];
ad[adv_len].data_len = cmd->adv_data[i++];
ad[adv_len].data = &cmd->adv_data[i];
i += ad[adv_len].data_len;
}
if (bt_le_adv_start(BT_LE_ADV(adv_type), ad, adv_len, NULL, 0) < 0) {
BTTESTER_DBG("Failed to start advertising");
goto fail;
}
atomic_set_bit(¤t_settings, GAP_SETTINGS_ADVERTISING);
rp.current_settings = sys_cpu_to_le32(current_settings);
tester_send(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
(uint8_t *) &rp, sizeof(rp));
return;
fail:
tester_rsp(BTP_SERVICE_ID_GAP, GAP_START_ADVERTISING, CONTROLLER_INDEX,
BTP_STATUS_FAILED);
}
static void bt_ready(int err)
{
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
printk("Bluetooth initialized\n");
gap_init(DEVICE_NAME, HEART_RATE_APPEARANCE);
hrs_init(0x01);
bas_init();
dis_init(CONFIG_SOC, "Manufacturer");
err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad),
sd, ARRAY_SIZE(sd));
if (err) {
printk("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
}
static void bt_ready(int err)
{
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
printk("Bluetooth initialized\n");
gap_init(DEVICE_NAME, CSC_APPEARANCE);
bas_init();
dis_init(CONFIG_SOC, "ACME");
bt_gatt_register(csc_attrs, ARRAY_SIZE(csc_attrs));
err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad),
sd, ARRAY_SIZE(sd));
if (err) {
printk("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
}
static void bt_ready(int err)
{
if (err) {
printk("Bluetooth init failed (err %d)\n", err);
return;
}
printk("Bluetooth initialized\n");
bt_gatt_register(gap_attrs, ARRAY_SIZE(gap_attrs));
bt_gatt_register(bas_attrs, ARRAY_SIZE(bas_attrs));
bt_gatt_register(dis_attrs, ARRAY_SIZE(dis_attrs));
bt_gatt_register(csc_attrs, ARRAY_SIZE(csc_attrs));
err = bt_le_adv_start(BT_LE_ADV(BT_LE_ADV_IND), ad, ARRAY_SIZE(ad),
sd, ARRAY_SIZE(sd));
if (err) {
printk("Advertising failed to start (err %d)\n", err);
return;
}
printk("Advertising successfully started\n");
}
static int cmd_advertise(int argc, char *argv[])
{
struct bt_le_adv_param param;
const struct bt_data *ad, *scan_rsp;
size_t ad_len, scan_rsp_len;
if (argc < 2) {
goto fail;
}
if (!strcmp(argv[1], "off")) {
if (bt_le_adv_stop() < 0) {
printk("Failed to stop advertising\n");
} else {
printk("Advertising stopped\n");
}
return 0;
}
param.interval_min = BT_GAP_ADV_FAST_INT_MIN_2;
param.interval_max = BT_GAP_ADV_FAST_INT_MAX_2;
if (!strcmp(argv[1], "on")) {
param.options = BT_LE_ADV_OPT_CONNECTABLE;
scan_rsp = sd;
scan_rsp_len = ARRAY_SIZE(sd);
} else if (!strcmp(argv[1], "scan")) {
param.options = 0;
scan_rsp = sd;
scan_rsp_len = ARRAY_SIZE(sd);
} else if (!strcmp(argv[1], "nconn")) {
param.options = 0;
scan_rsp = NULL;
scan_rsp_len = 0;
} else {
goto fail;
}
/* Parse advertisement data */
if (argc >= 3) {
const char *mode = argv[2];
if (!strcmp(mode, "discov")) {
ad = ad_discov;
ad_len = ARRAY_SIZE(ad_discov);
} else if (!strcmp(mode, "non_discov")) {
ad = NULL;
ad_len = 0;
} else {
goto fail;
}
} else {
ad = ad_discov;
ad_len = ARRAY_SIZE(ad_discov);
}
if (bt_le_adv_start(¶m, ad, ad_len, scan_rsp, scan_rsp_len) < 0) {
printk("Failed to start advertising\n");
} else {
printk("Advertising started\n");
}
return 0;
fail:
return -EINVAL;
}
static void advertise_start(enum ble_adv_reason reason)
{
size_t adv_len;
struct bt_le_adv_param adv_param;
uint16_t interval;
uint16_t timeout;
struct bt_data ad[] = {
BT_DATA_BYTES(BT_DATA_FLAGS,
(BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
BT_DATA_BYTES(BT_DATA_GAP_APPEARANCE, BLE_APP_APPEARANCE & 0xFF,
BLE_APP_APPEARANCE >> 8),
BT_DATA_BYTES(BT_DATA_MANUFACTURER_DATA, BLE_APP_MANUFACTURER &
0xFF,
BLE_APP_MANUFACTURER >> 8),
BT_DATA(BT_DATA_NAME_COMPLETE, _ble_app_cb.device_name,
strlen((char *)_ble_app_cb.device_name))
};
struct bt_data *ad_name = &ad[3];
int status;
pr_info(LOG_MODULE_MAIN, "advertise_start: reason:0x%x", reason);
switch (reason) {
case BLE_ADV_USER1:
case BLE_ADV_USER2:
case BLE_ADV_DISCONNECT:
timeout = CONFIG_BLE_APP_DEFAULT_ADV_TIMEOUT;
interval = CONFIG_BLE_APP_DEFAULT_ADV_INTERVAL;
break;
case BLE_ADV_TIMEOUT:
interval = CONFIG_BLE_ADV_SLOW_INTERVAL;
timeout = CONFIG_BLE_ADV_SLOW_TIMEOUT;
break;
case BLE_ADV_STARTUP:
interval = CONFIG_BLE_ULTRA_FAST_ADV_INTERVAL;
if (get_boot_target() == TARGET_RECOVERY)
timeout = 0;
else
timeout = CONFIG_BLE_APP_DEFAULT_ADV_TIMEOUT;
break;
default:
interval = CONFIG_BLE_APP_DEFAULT_ADV_INTERVAL;
timeout = 0;
break;
}
adv_param.type = BT_LE_ADV_IND;
adv_param.interval_max = interval;
adv_param.interval_min = interval;
adv_param.addr_type = _ble_app_cb.my_bd_addr.type;
adv_len = adv_data_len(ad, ARRAY_SIZE(ad)) + 2 * ARRAY_SIZE(ad);
if (adv_len > 31) {
ad_name->data_len -= adv_len - 31;
ad_name->type = BT_DATA_NAME_SHORTENED;
}
status = bt_le_adv_start(&adv_param, ad, ARRAY_SIZE(ad), NULL, 0);
if (!status && timeout)
ble_app_adv_timer_start(timeout, adv_timeout_cb);
if (status)
pr_error(LOG_MODULE_MAIN, "start_adv err %d", status);
}
