tools/mgmt-tester.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *  BlueZ - Bluetooth protocol stack for Linux
   5  *
   6  *  Copyright (C) 2012  Intel Corporation. All rights reserved.
   7  *
   8  *
   9  */
  10
  11 #ifdef HAVE_CONFIG_H
  12 #include <config.h>
  13 #endif
  14
  15 #include <stdlib.h>
  16 #include <stdbool.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/stat.h>
  19 #include <sys/types.h>
  20 #include <fcntl.h>
  21 #include <errno.h>
  22 #include <unistd.h>
  23
  24 #include <glib.h>
  25
  26 #include "lib/bluetooth.h"
  27 #include "lib/hci.h"
  28 #include "lib/hci_lib.h"
  29 #include "lib/mgmt.h"
  30 #include "lib/l2cap.h"
  31
  32 #include "monitor/bt.h"
  33 #include "emulator/vhci.h"
  34 #include "emulator/bthost.h"
  35 #include "emulator/hciemu.h"
  36
  37 #include "src/shared/util.h"
  38 #include "src/shared/tester.h"
  39 #include "src/shared/mgmt.h"
  40 #include "src/shared/queue.h"
  41
  42 struct test_data {
  43         tester_data_func_t test_setup;
  44         const void *test_data;
  45         uint8_t expected_version;
  46         uint16_t expected_manufacturer;
  47         uint32_t expected_supported_settings;
  48         uint32_t initial_settings;
  49         struct mgmt *mgmt;
  50         struct mgmt *mgmt_alt;
  51         unsigned int mgmt_settings_id;
  52         unsigned int mgmt_alt_settings_id;
  53         unsigned int mgmt_alt_ev_id;
  54         unsigned int mgmt_discov_ev_id;
  55         uint8_t mgmt_version;
  56         uint16_t mgmt_revision;
  57         uint16_t mgmt_index;
  58         struct hciemu *hciemu;
  59         enum hciemu_type hciemu_type;
  60         bool expect_hci_command_done;
  61         struct queue *expect_hci_q;
  62         int unmet_conditions;
  63         int unmet_setup_conditions;
  64         int sk;
  65 };
  66
  67 static void print_debug(const char *str, void *user_data)
  68 {
  69         const char *prefix = user_data;
  70
  71         tester_print("%s%s", prefix, str);
  72 }
  73
  74 static void test_post_teardown(const void *test_data)
  75 {
  76         struct test_data *data = tester_get_data();
  77
  78         if (data->sk >= 0)
  79                 close(data->sk);
  80
  81         queue_destroy(data->expect_hci_q, NULL);
  82
  83         hciemu_unref(data->hciemu);
  84         data->hciemu = NULL;
  85 }
  86
  87 static void test_pre_setup_failed(void)
  88 {
  89         test_post_teardown(NULL);
  90         tester_pre_setup_failed();
  91 }
  92
  93 static void read_version_callback(uint8_t status, uint16_t length,
  94                                         const void *param, void *user_data)
  95 {
  96         struct test_data *data = tester_get_data();
  97         const struct mgmt_rp_read_version *rp = param;
  98
  99         tester_print("Read Version callback");
 100         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 101
 102         if (status || !param) {
 103                 test_pre_setup_failed();
 104                 return;
 105         }
 106
 107         data->mgmt_version = rp->version;
 108         data->mgmt_revision = btohs(rp->revision);
 109
 110         tester_print("  Version %u.%u",
 111                                 data->mgmt_version, data->mgmt_revision);
 112 }
 113
 114 static void read_commands_callback(uint8_t status, uint16_t length,
 115                                         const void *param, void *user_data)
 116 {
 117         tester_print("Read Commands callback");
 118         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 119
 120         if (status || !param) {
 121                 test_pre_setup_failed();
 122                 return;
 123         }
 124 }
 125
 126 static bool check_settings(uint32_t supported, uint32_t expected)
 127 {
 128         int i;
 129
 130         if (supported == expected)
 131                 return true;
 132
 133         for (i = 0; i < 17; i++) {
 134                 if (supported & BIT(i))
 135                         continue;
 136
 137                 if (expected & BIT(i)) {
 138                         tester_warn("Expected bit %u not supported", i);
 139                         return false;
 140                 }
 141         }
 142
 143         return true;
 144 }
 145
 146 static void read_info_callback(uint8_t status, uint16_t length,
 147                                         const void *param, void *user_data)
 148 {
 149         struct test_data *data = tester_get_data();
 150         const struct mgmt_rp_read_info *rp = param;
 151         char addr[18];
 152         uint16_t manufacturer;
 153         uint32_t supported_settings, current_settings;
 154         struct bthost *bthost;
 155
 156         tester_print("Read Info callback");
 157         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 158
 159         if (status || !param) {
 160                 test_pre_setup_failed();
 161                 return;
 162         }
 163
 164         ba2str(&rp->bdaddr, addr);
 165         manufacturer = btohs(rp->manufacturer);
 166         supported_settings = btohl(rp->supported_settings);
 167         current_settings = btohl(rp->current_settings);
 168
 169         tester_print("  Address: %s", addr);
 170         tester_print("  Version: 0x%02x", rp->version);
 171         tester_print("  Manufacturer: 0x%04x", manufacturer);
 172         tester_print("  Supported settings: 0x%08x", supported_settings);
 173         tester_print("  Current settings: 0x%08x", current_settings);
 174         tester_print("  Class: 0x%02x%02x%02x",
 175                         rp->dev_class[2], rp->dev_class[1], rp->dev_class[0]);
 176         tester_print("  Name: %s", rp->name);
 177         tester_print("  Short name: %s", rp->short_name);
 178
 179         if (strcmp(hciemu_get_address(data->hciemu), addr)) {
 180                 test_pre_setup_failed();
 181                 return;
 182         }
 183
 184         if (rp->version != data->expected_version) {
 185                 tester_warn("Expected version: 0x%02x != 0x%02x",
 186                                 rp->version, data->expected_version);
 187                 test_pre_setup_failed();
 188                 return;
 189         }
 190
 191         if (manufacturer != data->expected_manufacturer) {
 192                 tester_warn("Expected manufacturer: 0x%04x != 0x%04x",
 193                                 manufacturer, data->expected_manufacturer);
 194                 test_pre_setup_failed();
 195                 return;
 196         }
 197
 198         if (!check_settings(supported_settings,
 199                                 data->expected_supported_settings)) {
 200                 tester_warn("Expected supported settings: 0x%08x != 0x%08x",
 201                                 supported_settings,
 202                                 data->expected_supported_settings);
 203                 test_pre_setup_failed();
 204                 return;
 205         }
 206
 207         if (!check_settings(current_settings, data->initial_settings)) {
 208                 tester_warn("Initial settings: 0x%08x != 0x%08x",
 209                                 current_settings, data->initial_settings);
 210                 test_pre_setup_failed();
 211                 return;
 212         }
 213
 214         if (rp->dev_class[0] != 0x00 || rp->dev_class[1] != 0x00 ||
 215                                                 rp->dev_class[2] != 0x00) {
 216                 test_pre_setup_failed();
 217                 return;
 218         }
 219
 220         bthost = hciemu_client_get_host(data->hciemu);
 221         bthost_notify_ready(bthost, tester_pre_setup_complete);
 222 }
 223
 224 static void index_added_callback(uint16_t index, uint16_t length,
 225                                         const void *param, void *user_data)
 226 {
 227         struct test_data *data = tester_get_data();
 228
 229         tester_print("Index Added callback");
 230         tester_print("  Index: 0x%04x", index);
 231
 232         data->mgmt_index = index;
 233
 234         mgmt_send(data->mgmt, MGMT_OP_READ_INFO, data->mgmt_index, 0, NULL,
 235                                         read_info_callback, NULL, NULL);
 236 }
 237
 238 static void index_removed_callback(uint16_t index, uint16_t length,
 239                                         const void *param, void *user_data)
 240 {
 241         struct test_data *data = tester_get_data();
 242
 243         tester_print("Index Removed callback");
 244         tester_print("  Index: 0x%04x", index);
 245
 246         if (index != data->mgmt_index)
 247                 return;
 248
 249         mgmt_unregister_index(data->mgmt, data->mgmt_index);
 250         mgmt_unregister_index(data->mgmt_alt, data->mgmt_index);
 251
 252         mgmt_unref(data->mgmt);
 253         data->mgmt = NULL;
 254
 255         mgmt_unref(data->mgmt_alt);
 256         data->mgmt_alt = NULL;
 257
 258         tester_post_teardown_complete();
 259 }
 260
 261 struct hci_cmd_data {
 262         uint16_t opcode;
 263         uint8_t len;
 264         const void *param;
 265 };
 266
 267 struct hci_entry {
 268         const struct hci_cmd_data *cmd_data;
 269 };
 270
 271 struct generic_data {
 272         bool setup_le_states;
 273         const uint8_t *le_states;
 274         const uint16_t *setup_settings;
 275         bool setup_nobredr;
 276         bool setup_limited_discov;
 277         const void *setup_exp_feat_param;
 278         uint16_t setup_expect_hci_command;
 279         const void *setup_expect_hci_param;
 280         uint8_t setup_expect_hci_len;
 281         uint16_t setup_send_opcode;
 282         const void *setup_send_param;
 283         uint16_t setup_send_len;
 284         const struct setup_mgmt_cmd *setup_mgmt_cmd_arr;
 285         bool send_index_none;
 286         const void *setup_discovery_param;
 287         uint16_t send_opcode;
 288         const void *send_param;
 289         uint16_t send_len;
 290         const void * (*send_func)(uint16_t *len);
 291         uint8_t expect_status;
 292         bool expect_ignore_param;
 293         const void *expect_param;
 294         uint16_t expect_len;
 295         const void * (*expect_func)(uint16_t *len);
 296         uint32_t expect_settings_set;
 297         uint32_t expect_settings_unset;
 298         uint16_t expect_alt_ev;
 299         const void *expect_alt_ev_param;
 300         bool (*verify_alt_ev_func)(const void *param, uint16_t length);
 301         uint16_t expect_alt_ev_len;
 302         uint16_t expect_hci_command;
 303         const void *expect_hci_param;
 304         int (*expect_hci_param_check_func)(const void *param, uint16_t length);
 305         uint8_t expect_hci_len;
 306         const void * (*expect_hci_func)(uint8_t *len);
 307         const struct hci_cmd_data *expect_hci_list;
 308         bool expect_pin;
 309         uint8_t pin_len;
 310         const void *pin;
 311         uint8_t client_pin_len;
 312         const void *client_pin;
 313         bool client_enable_ssp;
 314         uint8_t io_cap;
 315         uint8_t client_io_cap;
 316         uint8_t client_auth_req;
 317         bool reject_confirm;
 318         bool client_reject_confirm;
 319         bool just_works;
 320         bool client_enable_le;
 321         bool client_enable_sc;
 322         bool client_enable_adv;
 323         bool expect_sc_key;
 324         bool force_power_off;
 325         bool addr_type_avail;
 326         bool fail_tolerant;
 327         uint8_t addr_type;
 328         bool set_adv;
 329         const uint8_t *adv_data;
 330         uint8_t adv_data_len;
 331 };
 332
 333 static const uint8_t set_exp_feat_param_debug[] = {
 334         0x1c, 0xda, 0x47, 0x1c, 0x48, 0x6c, 0x01, 0xab, /* UUID - Debug */
 335         0x9f, 0x46, 0xec, 0xb9, 0x30, 0x25, 0x99, 0xd4,
 336         0x01,                                           /* Action - enable */
 337 };
 338
 339 static void debug_exp_callback(uint8_t status, uint16_t length,
 340                                         const void *param, void *user_data)
 341 {
 342         if (status != MGMT_STATUS_SUCCESS) {
 343                 tester_print("Debug feature could not be enabled");
 344                 return;
 345         }
 346
 347         tester_print("Debug feature is enabled");
 348 }
 349
 350 static void debug_exp_feature(struct test_data *data)
 351 {
 352         tester_print("Enabling Debug feature");
 353
 354         mgmt_send(data->mgmt, MGMT_OP_SET_EXP_FEATURE, MGMT_INDEX_NONE,
 355                   sizeof(set_exp_feat_param_debug), set_exp_feat_param_debug,
 356                   debug_exp_callback, NULL, NULL);
 357 }
 358
 359 static void read_index_list_callback(uint8_t status, uint16_t length,
 360                                         const void *param, void *user_data)
 361 {
 362         struct test_data *data = tester_get_data();
 363         const struct generic_data *test = data->test_data;
 364
 365         tester_print("Read Index List callback");
 366         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 367
 368         if (status || !param) {
 369                 test_pre_setup_failed();
 370                 return;
 371         }
 372
 373         mgmt_register(data->mgmt, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
 374                                         index_added_callback, NULL, NULL);
 375
 376         mgmt_register(data->mgmt, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
 377                                         index_removed_callback, NULL, NULL);
 378
 379         data->hciemu = hciemu_new(data->hciemu_type);
 380         if (!data->hciemu) {
 381                 tester_warn("Failed to setup HCI emulation");
 382                 test_pre_setup_failed();
 383         }
 384
 385         if (tester_use_debug())
 386                 hciemu_set_debug(data->hciemu, print_debug, "hciemu: ", NULL);
 387
 388         if (test && test->setup_le_states)
 389                 hciemu_set_central_le_states(data->hciemu, test->le_states);
 390 }
 391
 392 static void test_pre_setup(const void *test_data)
 393 {
 394         struct test_data *data = tester_get_data();
 395
 396         data->mgmt = mgmt_new_default();
 397         if (!data->mgmt) {
 398                 tester_warn("Failed to setup management interface");
 399                 test_pre_setup_failed();
 400                 return;
 401         }
 402
 403         data->mgmt_alt = mgmt_new_default();
 404         if (!data->mgmt_alt) {
 405                 tester_warn("Failed to setup alternate management interface");
 406                 test_pre_setup_failed();
 407
 408                 mgmt_unref(data->mgmt);
 409                 data->mgmt = NULL;
 410                 return;
 411         }
 412
 413         if (tester_use_debug()) {
 414                 mgmt_set_debug(data->mgmt, print_debug, "mgmt: ", NULL);
 415                 mgmt_set_debug(data->mgmt_alt, print_debug, "mgmt-alt: ", NULL);
 416                 debug_exp_feature(data);
 417         }
 418
 419         mgmt_send(data->mgmt, MGMT_OP_READ_VERSION, MGMT_INDEX_NONE, 0, NULL,
 420                                         read_version_callback, NULL, NULL);
 421
 422         mgmt_send(data->mgmt, MGMT_OP_READ_COMMANDS, MGMT_INDEX_NONE, 0, NULL,
 423                                         read_commands_callback, NULL, NULL);
 424
 425         mgmt_send(data->mgmt, MGMT_OP_READ_INDEX_LIST, MGMT_INDEX_NONE, 0, NULL,
 426                                         read_index_list_callback, NULL, NULL);
 427
 428         data->sk = -1;
 429 }
 430
 431 static void test_add_condition(struct test_data *data)
 432 {
 433         data->unmet_conditions++;
 434
 435         tester_print("Test condition added, total %d", data->unmet_conditions);
 436 }
 437
 438 static void test_add_setup_condition(struct test_data *data)
 439 {
 440         data->unmet_setup_conditions++;
 441
 442         tester_print("Test setup condition added, total %d",
 443                      data->unmet_setup_conditions);
 444 }
 445
 446 static void test_setup_condition_complete(struct test_data *data)
 447 {
 448         data->unmet_setup_conditions--;
 449
 450         tester_print("Test setup condition complete, %d left",
 451                      data->unmet_setup_conditions);
 452
 453         if (data->unmet_setup_conditions > 0)
 454                 return;
 455
 456         tester_setup_complete();
 457 }
 458
 459 static void test_condition_complete(struct test_data *data)
 460 {
 461         data->unmet_conditions--;
 462
 463         tester_print("Test condition complete, %d left",
 464                                                 data->unmet_conditions);
 465
 466         if (data->unmet_conditions > 0)
 467                 return;
 468
 469         tester_test_passed();
 470 }
 471
 472 #define test_full(name, data, setup, func, timeout, type, version, \
 473                         expected_settings, settings) \
 474         do { \
 475                 struct test_data *user; \
 476                 user = new0(struct test_data, 1); \
 477                 user->hciemu_type = type; \
 478                 user->test_setup = setup; \
 479                 user->test_data = data; \
 480                 user->expected_version = version; \
 481                 user->expected_manufacturer = 0x05f1; \
 482                 user->expected_supported_settings = expected_settings; \
 483                 user->initial_settings = settings; \
 484                 tester_add_full(name, data, \
 485                                 test_pre_setup, test_setup, func, NULL, \
 486                                 test_post_teardown, timeout, user, free); \
 487         } while (0)
 488
 489 #define test_bredrle_full(name, data, setup, func, timeout) \
 490         test_full(name, data, setup, func, timeout, HCIEMU_TYPE_BREDRLE, \
 491                                         0x09, 0x0001beff, 0x00000080)
 492
 493 #define test_bredrle(name, data, setup, func) \
 494         test_bredrle_full(name, data, setup, func, 2)
 495
 496 #define test_bredr20(name, data, setup, func) \
 497         test_full(name, data, setup, func, 2, HCIEMU_TYPE_LEGACY, \
 498                                         0x03, 0x000110bf, 0x00000080)
 499
 500 #define test_bredr(name, data, setup, func) \
 501         test_full(name, data, setup, func, 2, HCIEMU_TYPE_BREDR, \
 502                                         0x05, 0x000110ff, 0x00000080)
 503
 504 #define test_le_full(name, data, setup, func, timeout) \
 505         test_full(name, data, setup, func, timeout, HCIEMU_TYPE_LE, \
 506                                         0x09, 0x0001be1b, 0x00000200)
 507
 508 #define test_le(name, data, setup, func) \
 509         test_le_full(name, data, setup, func, 2)
 510
 511 #define test_bredrle50_full(name, data, setup, func, timeout) \
 512         test_full(name, data, setup, func, timeout, HCIEMU_TYPE_BREDRLE50, \
 513                                         0x09, 0x0001beff, 0x00000080)
 514
 515 #define test_bredrle50(name, data, setup, func) \
 516         test_bredrle50_full(name, data, setup, func, 2)
 517
 518 #define test_hs_full(name, data, setup, func, timeout) \
 519         test_full(name, data, setup, func, timeout, HCIEMU_TYPE_BREDRLE, \
 520                                         0x09, 0x0001bfff, 0x00000080)
 521
 522 #define test_hs(name, data, setup, func) \
 523         test_hs_full(name, data, setup, func, 2)
 524
 525 static void controller_setup(const void *test_data)
 526 {
 527         tester_test_passed();
 528 }
 529
 530 struct setup_mgmt_cmd {
 531         uint8_t send_opcode;
 532         const void *send_param;
 533         uint16_t send_len;
 534 };
 535
 536 static const char dummy_data[] = { 0x00 };
 537
 538 static const struct generic_data invalid_command_test = {
 539         .send_opcode = 0xffff,
 540         .expect_status = MGMT_STATUS_UNKNOWN_COMMAND,
 541 };
 542
 543 static const struct generic_data read_version_success_test = {
 544         .send_index_none = true,
 545         .send_opcode = MGMT_OP_READ_VERSION,
 546         .expect_status = MGMT_STATUS_SUCCESS,
 547         .expect_len = 3,
 548 };
 549
 550 static const struct generic_data read_version_invalid_param_test = {
 551         .send_index_none = true,
 552         .send_opcode = MGMT_OP_READ_VERSION,
 553         .send_param = dummy_data,
 554         .send_len = sizeof(dummy_data),
 555         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 556 };
 557
 558 static const struct generic_data read_version_invalid_index_test = {
 559         .send_opcode = MGMT_OP_READ_VERSION,
 560         .expect_status = MGMT_STATUS_INVALID_INDEX,
 561 };
 562
 563 static const struct generic_data read_commands_invalid_param_test = {
 564         .send_index_none = true,
 565         .send_opcode = MGMT_OP_READ_COMMANDS,
 566         .send_param = dummy_data,
 567         .send_len = sizeof(dummy_data),
 568         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 569 };
 570
 571 static const struct generic_data read_commands_invalid_index_test = {
 572         .send_opcode = MGMT_OP_READ_COMMANDS,
 573         .expect_status = MGMT_STATUS_INVALID_INDEX,
 574 };
 575
 576 static const struct generic_data read_index_list_invalid_param_test = {
 577         .send_index_none = true,
 578         .send_opcode = MGMT_OP_READ_INDEX_LIST,
 579         .send_param = dummy_data,
 580         .send_len = sizeof(dummy_data),
 581         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 582 };
 583
 584 static const struct generic_data read_index_list_invalid_index_test = {
 585         .send_opcode = MGMT_OP_READ_INDEX_LIST,
 586         .expect_status = MGMT_STATUS_INVALID_INDEX,
 587 };
 588
 589 static const struct generic_data read_info_invalid_param_test = {
 590         .send_opcode = MGMT_OP_READ_INFO,
 591         .send_param = dummy_data,
 592         .send_len = sizeof(dummy_data),
 593         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 594 };
 595
 596 static const struct generic_data read_info_invalid_index_test = {
 597         .send_index_none = true,
 598         .send_opcode = MGMT_OP_READ_INFO,
 599         .expect_status = MGMT_STATUS_INVALID_INDEX,
 600 };
 601
 602 static const struct generic_data read_unconf_index_list_invalid_param_test = {
 603         .send_index_none = true,
 604         .send_opcode = MGMT_OP_READ_UNCONF_INDEX_LIST,
 605         .send_param = dummy_data,
 606         .send_len = sizeof(dummy_data),
 607         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 608 };
 609
 610 static const struct generic_data read_unconf_index_list_invalid_index_test = {
 611         .send_opcode = MGMT_OP_READ_UNCONF_INDEX_LIST,
 612         .expect_status = MGMT_STATUS_INVALID_INDEX,
 613 };
 614
 615 static const struct generic_data read_config_info_invalid_param_test = {
 616         .send_opcode = MGMT_OP_READ_CONFIG_INFO,
 617         .send_param = dummy_data,
 618         .send_len = sizeof(dummy_data),
 619         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 620 };
 621
 622 static const struct generic_data read_config_info_invalid_index_test = {
 623         .send_index_none = true,
 624         .send_opcode = MGMT_OP_READ_CONFIG_INFO,
 625         .expect_status = MGMT_STATUS_INVALID_INDEX,
 626 };
 627
 628 static const struct generic_data read_ext_index_list_invalid_param_test = {
 629         .send_index_none = true,
 630         .send_opcode = MGMT_OP_READ_EXT_INDEX_LIST,
 631         .send_param = dummy_data,
 632         .send_len = sizeof(dummy_data),
 633         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 634 };
 635
 636 static const struct generic_data read_ext_index_list_invalid_index_test = {
 637         .send_opcode = MGMT_OP_READ_EXT_INDEX_LIST,
 638         .expect_status = MGMT_STATUS_INVALID_INDEX,
 639 };
 640
 641 static const char set_powered_on_param[] = { 0x01 };
 642 static const char set_powered_invalid_param[] = { 0x02 };
 643 static const char set_powered_garbage_param[] = { 0x01, 0x00 };
 644 static const char set_powered_settings_param[] = { 0x81, 0x00, 0x00, 0x00 };
 645
 646 static const struct generic_data set_powered_on_success_test = {
 647         .send_opcode = MGMT_OP_SET_POWERED,
 648         .send_param = set_powered_on_param,
 649         .send_len = sizeof(set_powered_on_param),
 650         .expect_status = MGMT_STATUS_SUCCESS,
 651         .expect_param = set_powered_settings_param,
 652         .expect_len = sizeof(set_powered_settings_param),
 653         .expect_settings_set = MGMT_SETTING_POWERED,
 654 };
 655
 656 static const struct generic_data set_powered_on_invalid_param_test_1 = {
 657         .send_opcode = MGMT_OP_SET_POWERED,
 658         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 659 };
 660
 661 static const struct generic_data set_powered_on_invalid_param_test_2 = {
 662         .send_opcode = MGMT_OP_SET_POWERED,
 663         .send_param = set_powered_invalid_param,
 664         .send_len = sizeof(set_powered_invalid_param),
 665         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 666 };
 667
 668 static const struct generic_data set_powered_on_invalid_param_test_3 = {
 669         .send_opcode = MGMT_OP_SET_POWERED,
 670         .send_param = set_powered_garbage_param,
 671         .send_len = sizeof(set_powered_garbage_param),
 672         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 673 };
 674
 675 static const struct generic_data set_powered_on_invalid_index_test = {
 676         .send_index_none = true,
 677         .send_opcode = MGMT_OP_SET_POWERED,
 678         .send_param = set_powered_on_param,
 679         .send_len = sizeof(set_powered_on_param),
 680         .expect_status = MGMT_STATUS_INVALID_INDEX,
 681 };
 682
 683 static uint16_t settings_powered_advertising_privacy[] = {
 684                                                 MGMT_OP_SET_PRIVACY,
 685                                                 MGMT_OP_SET_ADVERTISING,
 686                                                 MGMT_OP_SET_POWERED, 0 };
 687
 688 static const char set_adv_off_param[] = { 0x00 };
 689
 690 static const struct generic_data set_powered_on_privacy_adv_test = {
 691         .setup_settings = settings_powered_advertising_privacy,
 692         .send_opcode = MGMT_OP_SET_ADVERTISING,
 693         .send_param = set_adv_off_param,
 694         .send_len = sizeof(set_adv_off_param),
 695         .expect_status = MGMT_STATUS_SUCCESS,
 696         .expect_ignore_param = true,
 697 };
 698
 699 static const uint16_t settings_powered[] = { MGMT_OP_SET_POWERED, 0 };
 700
 701 static const char set_powered_off_param[] = { 0x00 };
 702 static const char set_powered_off_settings_param[] = { 0x80, 0x00, 0x00, 0x00 };
 703 static const char set_powered_off_class_of_dev[] = { 0x00, 0x00, 0x00 };
 704
 705 static const struct generic_data set_powered_off_success_test = {
 706         .setup_settings = settings_powered,
 707         .send_opcode = MGMT_OP_SET_POWERED,
 708         .send_param = set_powered_off_param,
 709         .send_len = sizeof(set_powered_off_param),
 710         .expect_status = MGMT_STATUS_SUCCESS,
 711         .expect_param = set_powered_off_settings_param,
 712         .expect_len = sizeof(set_powered_off_settings_param),
 713         .expect_settings_unset = MGMT_SETTING_POWERED,
 714 };
 715
 716 static const struct generic_data set_powered_off_class_test = {
 717         .send_opcode = MGMT_OP_SET_POWERED,
 718         .send_param = set_powered_off_param,
 719         .send_len = sizeof(set_powered_off_param),
 720         .expect_status = MGMT_STATUS_SUCCESS,
 721         .expect_param = set_powered_off_settings_param,
 722         .expect_len = sizeof(set_powered_off_settings_param),
 723         .expect_settings_unset = MGMT_SETTING_POWERED,
 724         .expect_alt_ev = MGMT_EV_CLASS_OF_DEV_CHANGED,
 725         .expect_alt_ev_param = set_powered_off_class_of_dev,
 726         .expect_alt_ev_len = sizeof(set_powered_off_class_of_dev),
 727 };
 728
 729 static const struct generic_data set_powered_off_invalid_param_test_1 = {
 730         .setup_settings = settings_powered,
 731         .send_opcode = MGMT_OP_SET_POWERED,
 732         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 733 };
 734
 735 static const struct generic_data set_powered_off_invalid_param_test_2 = {
 736         .setup_settings = settings_powered,
 737         .send_opcode = MGMT_OP_SET_POWERED,
 738         .send_param = set_powered_invalid_param,
 739         .send_len = sizeof(set_powered_invalid_param),
 740         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 741 };
 742
 743 static const struct generic_data set_powered_off_invalid_param_test_3 = {
 744         .setup_settings = settings_powered,
 745         .send_opcode = MGMT_OP_SET_POWERED,
 746         .send_param = set_powered_garbage_param,
 747         .send_len = sizeof(set_powered_garbage_param),
 748         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 749 };
 750
 751 static const char set_connectable_on_param[] = { 0x01 };
 752 static const char set_connectable_invalid_param[] = { 0x02 };
 753 static const char set_connectable_garbage_param[] = { 0x01, 0x00 };
 754 static const char set_connectable_settings_param_1[] = { 0x82, 0x00, 0x00, 0x00 };
 755 static const char set_connectable_settings_param_2[] = { 0x83, 0x00, 0x00, 0x00 };
 756 static const char set_connectable_scan_enable_param[] = { 0x02 };
 757
 758 static const struct generic_data set_connectable_on_success_test_1 = {
 759         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 760         .send_param = set_connectable_on_param,
 761         .send_len = sizeof(set_connectable_on_param),
 762         .expect_status = MGMT_STATUS_SUCCESS,
 763         .expect_param = set_connectable_settings_param_1,
 764         .expect_len = sizeof(set_connectable_settings_param_1),
 765         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 766 };
 767
 768 static const struct generic_data set_connectable_on_success_test_2 = {
 769         .setup_settings = settings_powered,
 770         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 771         .send_param = set_connectable_on_param,
 772         .send_len = sizeof(set_connectable_on_param),
 773         .expect_status = MGMT_STATUS_SUCCESS,
 774         .expect_param = set_connectable_settings_param_2,
 775         .expect_len = sizeof(set_connectable_settings_param_2),
 776         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 777         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 778         .expect_hci_param = set_connectable_scan_enable_param,
 779         .expect_hci_len = sizeof(set_connectable_scan_enable_param),
 780 };
 781
 782 static const struct generic_data set_connectable_on_invalid_param_test_1 = {
 783         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 784         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 785 };
 786
 787 static const struct generic_data set_connectable_on_invalid_param_test_2 = {
 788         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 789         .send_param = set_connectable_invalid_param,
 790         .send_len = sizeof(set_connectable_invalid_param),
 791         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 792 };
 793
 794 static const struct generic_data set_connectable_on_invalid_param_test_3 = {
 795         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 796         .send_param = set_connectable_garbage_param,
 797         .send_len = sizeof(set_connectable_garbage_param),
 798         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 799 };
 800
 801 static const struct generic_data set_connectable_on_invalid_index_test = {
 802         .send_index_none = true,
 803         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 804         .send_param = set_connectable_on_param,
 805         .send_len = sizeof(set_connectable_on_param),
 806         .expect_status = MGMT_STATUS_INVALID_INDEX,
 807 };
 808
 809 static uint16_t settings_powered_advertising[] = { MGMT_OP_SET_ADVERTISING,
 810                                                 MGMT_OP_SET_POWERED, 0 };
 811
 812 static const char set_connectable_le_settings_param_1[] = { 0x02, 0x02, 0x00, 0x00 };
 813 static const char set_connectable_le_settings_param_2[] = { 0x03, 0x02, 0x00, 0x00 };
 814 static const char set_connectable_le_settings_param_3[] = { 0x03, 0x06, 0x00, 0x00 };
 815
 816 static const struct generic_data set_connectable_on_le_test_1 = {
 817         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 818         .send_param = set_connectable_on_param,
 819         .send_len = sizeof(set_connectable_on_param),
 820         .expect_status = MGMT_STATUS_SUCCESS,
 821         .expect_param = set_connectable_le_settings_param_1,
 822         .expect_len = sizeof(set_connectable_le_settings_param_1),
 823         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 824 };
 825
 826 static const struct generic_data set_connectable_on_le_test_2 = {
 827         .setup_settings = settings_powered,
 828         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 829         .send_param = set_connectable_on_param,
 830         .send_len = sizeof(set_connectable_on_param),
 831         .expect_status = MGMT_STATUS_SUCCESS,
 832         .expect_param = set_connectable_le_settings_param_2,
 833         .expect_len = sizeof(set_connectable_le_settings_param_2),
 834         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 835 };
 836
 837 static uint8_t set_connectable_on_adv_param[] = {
 838                 0x00, 0x08,                             /* min_interval */
 839                 0x00, 0x08,                             /* max_interval */
 840                 0x00,                                   /* type */
 841                 0x00,                                   /* own_addr_type */
 842                 0x00,                                   /* direct_addr_type */
 843                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* direct_addr */
 844                 0x07,                                   /* channel_map */
 845                 0x00,                                   /* filter_policy */
 846 };
 847
 848 static const struct generic_data set_connectable_on_le_test_3 = {
 849         .setup_settings = settings_powered_advertising,
 850         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 851         .send_param = set_connectable_on_param,
 852         .send_len = sizeof(set_connectable_on_param),
 853         .expect_status = MGMT_STATUS_SUCCESS,
 854         .expect_param = set_connectable_le_settings_param_3,
 855         .expect_len = sizeof(set_connectable_le_settings_param_3),
 856         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 857         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
 858         .expect_hci_param = set_connectable_on_adv_param,
 859         .expect_hci_len = sizeof(set_connectable_on_adv_param),
 860 };
 861
 862 static const uint16_t settings_connectable[] = { MGMT_OP_SET_CONNECTABLE, 0 };
 863 static const uint16_t settings_powered_connectable[] = {
 864                                                 MGMT_OP_SET_CONNECTABLE,
 865                                                 MGMT_OP_SET_POWERED, 0 };
 866 static const uint16_t settings_powered_discoverable[] = {
 867                                                 MGMT_OP_SET_CONNECTABLE,
 868                                                 MGMT_OP_SET_DISCOVERABLE,
 869                                                 MGMT_OP_SET_POWERED, 0 };
 870
 871 static const char set_connectable_off_param[] = { 0x00 };
 872 static const char set_connectable_off_settings_1[] = { 0x80, 0x00, 0x00, 0x00 };
 873 static const char set_connectable_off_settings_2[] = { 0x81, 0x00, 0x00, 0x00 };
 874 static const char set_connectable_off_scan_enable_param[] = { 0x00 };
 875
 876 static const struct generic_data set_connectable_off_success_test_1 = {
 877         .setup_settings = settings_connectable,
 878         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 879         .send_param = set_connectable_off_param,
 880         .send_len = sizeof(set_connectable_off_param),
 881         .expect_status = MGMT_STATUS_SUCCESS,
 882         .expect_param = set_connectable_off_settings_1,
 883         .expect_len = sizeof(set_connectable_off_settings_1),
 884         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 885 };
 886
 887 static const struct generic_data set_connectable_off_success_test_2 = {
 888         .setup_settings = settings_powered_connectable,
 889         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 890         .send_param = set_connectable_off_param,
 891         .send_len = sizeof(set_connectable_off_param),
 892         .expect_status = MGMT_STATUS_SUCCESS,
 893         .expect_param = set_connectable_off_settings_2,
 894         .expect_len = sizeof(set_connectable_off_settings_2),
 895         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 896         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 897         .expect_hci_param = set_connectable_off_scan_enable_param,
 898         .expect_hci_len = sizeof(set_connectable_off_scan_enable_param),
 899 };
 900
 901 static const struct generic_data set_connectable_off_success_test_3 = {
 902         .setup_settings = settings_powered_discoverable,
 903         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 904         .send_param = set_connectable_off_param,
 905         .send_len = sizeof(set_connectable_off_param),
 906         .expect_status = MGMT_STATUS_SUCCESS,
 907         .expect_param = set_connectable_off_settings_2,
 908         .expect_len = sizeof(set_connectable_off_settings_2),
 909         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 910         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 911         .expect_hci_param = set_connectable_off_scan_enable_param,
 912         .expect_hci_len = sizeof(set_connectable_off_scan_enable_param),
 913 };
 914
 915 static const struct generic_data set_connectable_off_success_test_4 = {
 916         .setup_settings = settings_powered_discoverable,
 917         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 918         .send_param = set_connectable_off_param,
 919         .send_len = sizeof(set_connectable_off_param),
 920         .expect_status = MGMT_STATUS_SUCCESS,
 921         .expect_param = set_connectable_off_settings_2,
 922         .expect_len = sizeof(set_connectable_off_settings_2),
 923         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 924         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 925         .expect_hci_param = set_connectable_scan_enable_param,
 926         .expect_hci_len = sizeof(set_connectable_scan_enable_param),
 927 };
 928
 929 static const char set_connectable_off_le_settings_1[] = { 0x00, 0x02, 0x00, 0x00 };
 930 static const char set_connectable_off_le_settings_2[] = { 0x01, 0x06, 0x00, 0x00 };
 931
 932 static uint16_t settings_le_connectable[] = { MGMT_OP_SET_LE,
 933                                                 MGMT_OP_SET_CONNECTABLE, 0 };
 934
 935 static const struct generic_data set_connectable_off_le_test_1 = {
 936         .setup_settings = settings_le_connectable,
 937         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 938         .send_param = set_connectable_off_param,
 939         .send_len = sizeof(set_connectable_off_param),
 940         .expect_status = MGMT_STATUS_SUCCESS,
 941         .expect_param = set_connectable_off_le_settings_1,
 942         .expect_len = sizeof(set_connectable_off_le_settings_1),
 943         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 944 };
 945
 946 static uint16_t settings_powered_le_connectable_advertising[] = {
 947                                         MGMT_OP_SET_LE,
 948                                         MGMT_OP_SET_CONNECTABLE,
 949                                         MGMT_OP_SET_ADVERTISING,
 950                                         MGMT_OP_SET_POWERED, 0 };
 951
 952 static uint8_t set_connectable_off_scan_adv_param[] = {
 953                 0x64, 0x00,                             /* min_interval */
 954                 0x96, 0x00,                             /* max_interval */
 955                 0x02,                                   /* type */
 956                 0x01,                                   /* own_addr_type */
 957                 0x00,                                   /* direct_addr_type */
 958                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* direct_addr */
 959                 0x07,                                   /* channel_map */
 960                 0x00,                                   /* filter_policy */
 961 };
 962
 963 static int set_connectable_off_scan_adv_check_func(const void *param,
 964                                                                 uint16_t length)
 965 {
 966         const uint8_t *received = param;
 967         uint8_t *expected = set_connectable_off_scan_adv_param;
 968
 969         /* Compare the received param with expected param, but ignore the
 970          * min_internal and max_interval since these values are turned often
 971          * in the kernel and we don't want to update the expected value every
 972          * time.
 973          */
 974         return memcmp(&received[4], &expected[4], length - 4);
 975 }
 976
 977 static const struct generic_data set_connectable_off_le_test_2 = {
 978         .setup_settings = settings_powered_le_connectable_advertising,
 979         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 980         .send_param = set_connectable_off_param,
 981         .send_len = sizeof(set_connectable_off_param),
 982         .expect_status = MGMT_STATUS_SUCCESS,
 983         .expect_param = set_connectable_off_le_settings_2,
 984         .expect_len = sizeof(set_connectable_off_le_settings_2),
 985         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 986         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
 987         .expect_hci_param = set_connectable_off_scan_adv_param,
 988         .expect_hci_len = sizeof(set_connectable_off_scan_adv_param),
 989         .expect_hci_param_check_func = set_connectable_off_scan_adv_check_func
 990 };
 991
 992 static uint16_t settings_powered_le_discoverable[] = {
 993                                         MGMT_OP_SET_LE,
 994                                         MGMT_OP_SET_CONNECTABLE,
 995                                         MGMT_OP_SET_POWERED,
 996                                         MGMT_OP_SET_DISCOVERABLE, 0 };
 997
 998 static uint16_t settings_powered_le_discoverable_advertising[] = {
 999                                         MGMT_OP_SET_LE,
1000                                         MGMT_OP_SET_CONNECTABLE,
1001                                         MGMT_OP_SET_ADVERTISING,
1002                                         MGMT_OP_SET_POWERED,
1003                                         MGMT_OP_SET_DISCOVERABLE, 0 };
1004
1005 static const struct generic_data set_connectable_off_le_test_3 = {
1006         .setup_settings = settings_powered_le_discoverable_advertising,
1007         .send_opcode = MGMT_OP_SET_CONNECTABLE,
1008         .send_param = set_connectable_off_param,
1009         .send_len = sizeof(set_connectable_off_param),
1010         .expect_status = MGMT_STATUS_SUCCESS,
1011         .expect_param = set_connectable_off_le_settings_2,
1012         .expect_len = sizeof(set_connectable_off_le_settings_2),
1013         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
1014         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
1015         .expect_hci_param = set_connectable_off_scan_adv_param,
1016         .expect_hci_len = sizeof(set_connectable_off_scan_adv_param),
1017         .expect_hci_param_check_func = set_connectable_off_scan_adv_check_func
1018 };
1019
1020 static const struct generic_data set_connectable_off_le_test_4 = {
1021         .setup_settings = settings_powered_le_discoverable_advertising,
1022         .setup_limited_discov = true,
1023         .send_opcode = MGMT_OP_SET_CONNECTABLE,
1024         .send_param = set_connectable_off_param,
1025         .send_len = sizeof(set_connectable_off_param),
1026         .expect_status = MGMT_STATUS_SUCCESS,
1027         .expect_param = set_connectable_off_le_settings_2,
1028         .expect_len = sizeof(set_connectable_off_le_settings_2),
1029         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
1030         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
1031         .expect_hci_param = set_connectable_off_scan_adv_param,
1032         .expect_hci_len = sizeof(set_connectable_off_scan_adv_param),
1033         .expect_hci_param_check_func = set_connectable_off_scan_adv_check_func
1034 };
1035
1036 static const char set_fast_conn_on_param[] = { 0x01 };
1037 static const char set_fast_conn_on_settings_1[] = { 0x87, 0x00, 0x00, 0x00 };
1038 static const char set_fast_conn_on_settings_2[] = { 0x85, 0x00, 0x00, 0x00 };
1039 static const char set_fast_conn_on_settings_3[] = { 0x84, 0x00, 0x00, 0x00 };
1040
1041 static const struct generic_data set_fast_conn_on_success_test_1 = {
1042         .setup_settings = settings_powered_connectable,
1043         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
1044         .send_param = set_fast_conn_on_param,
1045         .send_len = sizeof(set_fast_conn_on_param),
1046         .expect_status = MGMT_STATUS_SUCCESS,
1047         .expect_param = set_fast_conn_on_settings_1,
1048         .expect_len = sizeof(set_fast_conn_on_settings_1),
1049         .expect_settings_set = MGMT_SETTING_FAST_CONNECTABLE,
1050 };
1051
1052 static const struct generic_data set_fast_conn_on_success_test_2 = {
1053         .setup_settings = settings_powered,
1054         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
1055         .send_param = set_fast_conn_on_param,
1056         .send_len = sizeof(set_fast_conn_on_param),
1057         .expect_status = MGMT_STATUS_SUCCESS,
1058         .expect_param = set_fast_conn_on_settings_2,
1059         .expect_len = sizeof(set_fast_conn_on_settings_2),
1060         .expect_settings_set = MGMT_SETTING_FAST_CONNECTABLE,
1061 };
1062
1063 static const struct generic_data set_fast_conn_on_success_test_3 = {
1064         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
1065         .send_param = set_fast_conn_on_param,
1066         .send_len = sizeof(set_fast_conn_on_param),
1067         .expect_status = MGMT_STATUS_SUCCESS,
1068         .expect_param = set_fast_conn_on_settings_3,
1069         .expect_len = sizeof(set_fast_conn_on_settings_3),
1070         .expect_settings_set = MGMT_SETTING_FAST_CONNECTABLE,
1071 };
1072
1073 static const struct generic_data set_fast_conn_on_not_supported_test_1 = {
1074         .setup_settings = settings_powered_connectable,
1075         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
1076         .send_param = set_fast_conn_on_param,
1077         .send_len = sizeof(set_fast_conn_on_param),
1078         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1079 };
1080
1081 static const char set_fast_conn_nval_param[] = { 0xff };
1082
1083 static const struct generic_data set_fast_conn_nval_param_test_1 = {
1084         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
1085         .send_param = set_fast_conn_nval_param,
1086         .send_len = sizeof(set_fast_conn_nval_param),
1087         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1088 };
1089
1090 static const char set_bondable_on_param[] = { 0x01 };
1091 static const char set_bondable_invalid_param[] = { 0x02 };
1092 static const char set_bondable_garbage_param[] = { 0x01, 0x00 };
1093 static const char set_bondable_settings_param[] = { 0x90, 0x00, 0x00, 0x00 };
1094
1095 static const struct generic_data set_bondable_on_success_test = {
1096         .send_opcode = MGMT_OP_SET_BONDABLE,
1097         .send_param = set_bondable_on_param,
1098         .send_len = sizeof(set_bondable_on_param),
1099         .expect_status = MGMT_STATUS_SUCCESS,
1100         .expect_param = set_bondable_settings_param,
1101         .expect_len = sizeof(set_bondable_settings_param),
1102         .expect_settings_set = MGMT_SETTING_BONDABLE,
1103 };
1104
1105 static const struct generic_data set_bondable_on_invalid_param_test_1 = {
1106         .send_opcode = MGMT_OP_SET_BONDABLE,
1107         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1108 };
1109
1110 static const struct generic_data set_bondable_on_invalid_param_test_2 = {
1111         .send_opcode = MGMT_OP_SET_BONDABLE,
1112         .send_param = set_bondable_invalid_param,
1113         .send_len = sizeof(set_bondable_invalid_param),
1114         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1115 };
1116
1117 static const struct generic_data set_bondable_on_invalid_param_test_3 = {
1118         .send_opcode = MGMT_OP_SET_BONDABLE,
1119         .send_param = set_bondable_garbage_param,
1120         .send_len = sizeof(set_bondable_garbage_param),
1121         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1122 };
1123
1124 static const struct generic_data set_bondable_on_invalid_index_test = {
1125         .send_index_none = true,
1126         .send_opcode = MGMT_OP_SET_BONDABLE,
1127         .send_param = set_bondable_on_param,
1128         .send_len = sizeof(set_bondable_on_param),
1129         .expect_status = MGMT_STATUS_INVALID_INDEX,
1130 };
1131
1132 static const uint8_t set_discoverable_on_param[] = { 0x01, 0x00, 0x00 };
1133 static const uint8_t set_discoverable_timeout_param[] = { 0x01, 0x0a, 0x00 };
1134 static const uint8_t set_discoverable_invalid_param[] = { 0x02, 0x00, 0x00 };
1135 static const uint8_t set_discoverable_off_param[] = { 0x00, 0x00, 0x00 };
1136 static const uint8_t set_discoverable_offtimeout_param[] = { 0x00, 0x01, 0x00 };
1137 static const uint8_t set_discoverable_garbage_param[] = { 0x01, 0x00, 0x00, 0x00 };
1138 static const uint8_t set_discoverable_on_settings_param_1[] = { 0x8a, 0x00, 0x00, 0x00 };
1139 static const uint8_t set_discoverable_on_settings_param_2[] = { 0x8b, 0x00, 0x00, 0x00 };
1140 static const uint8_t set_discoverable_off_settings_param_1[] = { 0x82, 0x00, 0x00, 0x00 };
1141 static const uint8_t set_discoverable_off_settings_param_2[] = { 0x83, 0x00, 0x00, 0x00 };
1142 static const uint8_t set_discoverable_on_scan_enable_param[] = { 0x03 };
1143 static const uint8_t set_discoverable_off_scan_enable_param[] = { 0x02 };
1144
1145 static const struct generic_data set_discoverable_on_invalid_param_test_1 = {
1146         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1147         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1148 };
1149
1150 static const struct generic_data set_discoverable_on_invalid_param_test_2 = {
1151         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1152         .send_param = set_discoverable_invalid_param,
1153         .send_len = sizeof(set_discoverable_invalid_param),
1154         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1155 };
1156
1157 static const struct generic_data set_discoverable_on_invalid_param_test_3 = {
1158         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1159         .send_param = set_discoverable_garbage_param,
1160         .send_len = sizeof(set_discoverable_garbage_param),
1161         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1162 };
1163
1164 static const struct generic_data set_discoverable_on_invalid_param_test_4 = {
1165         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1166         .send_param = set_discoverable_offtimeout_param,
1167         .send_len = sizeof(set_discoverable_offtimeout_param),
1168         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1169 };
1170
1171 static const struct generic_data set_discoverable_on_not_powered_test_1 = {
1172         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1173         .send_param = set_discoverable_timeout_param,
1174         .send_len = sizeof(set_discoverable_timeout_param),
1175         .expect_status = MGMT_STATUS_NOT_POWERED,
1176 };
1177
1178 static const struct generic_data set_discoverable_on_not_powered_test_2 = {
1179         .setup_settings = settings_connectable,
1180         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1181         .send_param = set_discoverable_timeout_param,
1182         .send_len = sizeof(set_discoverable_timeout_param),
1183         .expect_status = MGMT_STATUS_NOT_POWERED,
1184 };
1185
1186 static const struct generic_data set_discoverable_on_rejected_test_1 = {
1187         .setup_settings = settings_powered,
1188         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1189         .send_param = set_discoverable_on_param,
1190         .send_len = sizeof(set_discoverable_on_param),
1191         .expect_status = MGMT_STATUS_REJECTED,
1192 };
1193
1194 static const struct generic_data set_discoverable_on_rejected_test_2 = {
1195         .setup_settings = settings_powered,
1196         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1197         .send_param = set_discoverable_on_param,
1198         .send_len = sizeof(set_discoverable_on_param),
1199         .expect_status = MGMT_STATUS_REJECTED,
1200 };
1201
1202 static const struct generic_data set_discoverable_on_rejected_test_3 = {
1203         .setup_settings = settings_powered,
1204         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1205         .send_param = set_discoverable_timeout_param,
1206         .send_len = sizeof(set_discoverable_timeout_param),
1207         .expect_status = MGMT_STATUS_REJECTED,
1208 };
1209
1210 static const struct generic_data set_discoverable_on_success_test_1 = {
1211         .setup_settings = settings_connectable,
1212         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1213         .send_param = set_discoverable_on_param,
1214         .send_len = sizeof(set_discoverable_on_param),
1215         .expect_status = MGMT_STATUS_SUCCESS,
1216         .expect_param = set_discoverable_on_settings_param_1,
1217         .expect_len = sizeof(set_discoverable_on_settings_param_1),
1218         .expect_settings_set = MGMT_SETTING_DISCOVERABLE,
1219 };
1220
1221 static const struct generic_data set_discoverable_on_success_test_2 = {
1222         .setup_settings = settings_powered_connectable,
1223         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1224         .send_param = set_discoverable_on_param,
1225         .send_len = sizeof(set_discoverable_on_param),
1226         .expect_status = MGMT_STATUS_SUCCESS,
1227         .expect_param = set_discoverable_on_settings_param_2,
1228         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1229         .expect_settings_set = MGMT_SETTING_DISCOVERABLE,
1230         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
1231         .expect_hci_param = set_discoverable_on_scan_enable_param,
1232         .expect_hci_len = sizeof(set_discoverable_on_scan_enable_param),
1233 };
1234
1235 static uint8_t set_discov_on_le_param[] = { 0x0b, 0x06, 0x00, 0x00 };
1236 static uint8_t set_discov_adv_data[32] = { 0x06, 0x02, 0x01, 0x06,
1237                                                                 0x02, 0x0a, };
1238
1239 static const struct generic_data set_discov_on_le_success_1 = {
1240         .setup_settings = settings_powered_le_connectable_advertising,
1241         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1242         .send_param = set_discoverable_on_param,
1243         .send_len = sizeof(set_discoverable_on_param),
1244         .expect_status = MGMT_STATUS_SUCCESS,
1245         .expect_param = set_discov_on_le_param,
1246         .expect_len = sizeof(set_discov_on_le_param),
1247         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
1248         .expect_hci_param = set_discov_adv_data,
1249         .expect_hci_len = sizeof(set_discov_adv_data),
1250 };
1251
1252 static const struct generic_data set_discoverable_off_success_test_1 = {
1253         .setup_settings = settings_connectable,
1254         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1255         .send_param = set_discoverable_off_param,
1256         .send_len = sizeof(set_discoverable_off_param),
1257         .expect_status = MGMT_STATUS_SUCCESS,
1258         .expect_param = set_discoverable_off_settings_param_1,
1259         .expect_len = sizeof(set_discoverable_off_settings_param_1),
1260 };
1261
1262 static const struct generic_data set_discoverable_off_success_test_2 = {
1263         .setup_settings = settings_powered_discoverable,
1264         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1265         .send_param = set_discoverable_off_param,
1266         .send_len = sizeof(set_discoverable_off_param),
1267         .expect_status = MGMT_STATUS_SUCCESS,
1268         .expect_param = set_discoverable_off_settings_param_2,
1269         .expect_len = sizeof(set_discoverable_off_settings_param_2),
1270         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
1271         .expect_hci_param = set_discoverable_off_scan_enable_param,
1272         .expect_hci_len = sizeof(set_discoverable_off_scan_enable_param),
1273 };
1274
1275 static const uint8_t set_limited_discov_on_param[] = { 0x02, 0x01, 0x00 };
1276
1277 static const struct generic_data set_limited_discov_on_success_1 = {
1278         .setup_settings = settings_powered_connectable,
1279         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1280         .send_param = set_limited_discov_on_param,
1281         .send_len = sizeof(set_limited_discov_on_param),
1282         .expect_status = MGMT_STATUS_SUCCESS,
1283         .expect_param = set_discoverable_on_settings_param_2,
1284         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1285         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
1286         .expect_hci_param = set_discoverable_on_scan_enable_param,
1287         .expect_hci_len = sizeof(set_discoverable_on_scan_enable_param),
1288 };
1289
1290 static uint8_t write_current_iac_lap_limited[] = { 0x01, 0x00, 0x8b, 0x9e };
1291
1292 static const struct generic_data set_limited_discov_on_success_2 = {
1293         .setup_settings = settings_powered_connectable,
1294         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1295         .send_param = set_limited_discov_on_param,
1296         .send_len = sizeof(set_limited_discov_on_param),
1297         .expect_status = MGMT_STATUS_SUCCESS,
1298         .expect_param = set_discoverable_on_settings_param_2,
1299         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1300         .expect_hci_command = BT_HCI_CMD_WRITE_CURRENT_IAC_LAP,
1301         .expect_hci_param = write_current_iac_lap_limited,
1302         .expect_hci_len = sizeof(write_current_iac_lap_limited),
1303 };
1304
1305 static uint8_t write_cod_limited[] = { 0x00, 0x20, 0x00 };
1306
1307 static const struct generic_data set_limited_discov_on_success_3 = {
1308         .setup_settings = settings_powered_connectable,
1309         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1310         .send_param = set_limited_discov_on_param,
1311         .send_len = sizeof(set_limited_discov_on_param),
1312         .expect_status = MGMT_STATUS_SUCCESS,
1313         .expect_param = set_discoverable_on_settings_param_2,
1314         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1315         .expect_hci_command = BT_HCI_CMD_WRITE_CLASS_OF_DEV,
1316         .expect_hci_param = write_cod_limited,
1317         .expect_hci_len = sizeof(write_cod_limited),
1318 };
1319
1320 static uint8_t set_limited_discov_adv_data[32] = { 0x06, 0x02, 0x01, 0x05,
1321                                                                 0x02, 0x0a, };
1322
1323 static const struct generic_data set_limited_discov_on_le_success_1 = {
1324         .setup_settings = settings_powered_le_connectable_advertising,
1325         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1326         .send_param = set_limited_discov_on_param,
1327         .send_len = sizeof(set_limited_discov_on_param),
1328         .expect_status = MGMT_STATUS_SUCCESS,
1329         .expect_param = set_discov_on_le_param,
1330         .expect_len = sizeof(set_discov_on_le_param),
1331         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
1332         .expect_hci_param = set_limited_discov_adv_data,
1333         .expect_hci_len = sizeof(set_limited_discov_adv_data),
1334 };
1335
1336 static uint16_t settings_link_sec[] = { MGMT_OP_SET_LINK_SECURITY, 0 };
1337
1338 static const char set_link_sec_on_param[] = { 0x01 };
1339 static const char set_link_sec_invalid_param[] = { 0x02 };
1340 static const char set_link_sec_garbage_param[] = { 0x01, 0x00 };
1341 static const char set_link_sec_settings_param_1[] = { 0xa0, 0x00, 0x00, 0x00 };
1342 static const char set_link_sec_settings_param_2[] = { 0xa1, 0x00, 0x00, 0x00 };
1343 static const char set_link_sec_auth_enable_param[] = { 0x01 };
1344
1345 static const struct generic_data set_link_sec_on_success_test_1 = {
1346         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1347         .send_param = set_link_sec_on_param,
1348         .send_len = sizeof(set_link_sec_on_param),
1349         .expect_status = MGMT_STATUS_SUCCESS,
1350         .expect_param = set_link_sec_settings_param_1,
1351         .expect_len = sizeof(set_link_sec_settings_param_1),
1352         .expect_settings_set = MGMT_SETTING_LINK_SECURITY,
1353 };
1354
1355 static const struct generic_data set_link_sec_on_success_test_2 = {
1356         .setup_settings = settings_powered,
1357         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1358         .send_param = set_link_sec_on_param,
1359         .send_len = sizeof(set_link_sec_on_param),
1360         .expect_status = MGMT_STATUS_SUCCESS,
1361         .expect_param = set_link_sec_settings_param_2,
1362         .expect_len = sizeof(set_link_sec_settings_param_2),
1363         .expect_settings_set = MGMT_SETTING_LINK_SECURITY,
1364         .expect_hci_command = BT_HCI_CMD_WRITE_AUTH_ENABLE,
1365         .expect_hci_param = set_link_sec_auth_enable_param,
1366         .expect_hci_len = sizeof(set_link_sec_auth_enable_param),
1367 };
1368
1369 static const struct generic_data set_link_sec_on_success_test_3 = {
1370         .setup_settings = settings_link_sec,
1371         .send_opcode = MGMT_OP_SET_POWERED,
1372         .send_param = set_powered_on_param,
1373         .send_len = sizeof(set_powered_on_param),
1374         .expect_status = MGMT_STATUS_SUCCESS,
1375         .expect_param = set_link_sec_settings_param_2,
1376         .expect_len = sizeof(set_link_sec_settings_param_2),
1377         .expect_settings_set = MGMT_SETTING_LINK_SECURITY,
1378         .expect_hci_command = BT_HCI_CMD_WRITE_AUTH_ENABLE,
1379         .expect_hci_param = set_link_sec_auth_enable_param,
1380         .expect_hci_len = sizeof(set_link_sec_auth_enable_param),
1381 };
1382
1383 static const struct generic_data set_link_sec_on_invalid_param_test_1 = {
1384         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1385         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1386 };
1387
1388 static const struct generic_data set_link_sec_on_invalid_param_test_2 = {
1389         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1390         .send_param = set_link_sec_invalid_param,
1391         .send_len = sizeof(set_link_sec_invalid_param),
1392         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1393 };
1394
1395 static const struct generic_data set_link_sec_on_invalid_param_test_3 = {
1396         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1397         .send_param = set_link_sec_garbage_param,
1398         .send_len = sizeof(set_link_sec_garbage_param),
1399         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1400 };
1401
1402 static const struct generic_data set_link_sec_on_invalid_index_test = {
1403         .send_index_none = true,
1404         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1405         .send_param = set_link_sec_on_param,
1406         .send_len = sizeof(set_link_sec_on_param),
1407         .expect_status = MGMT_STATUS_INVALID_INDEX,
1408 };
1409
1410 static const uint16_t settings_powered_link_sec[] = {
1411                                                 MGMT_OP_SET_LINK_SECURITY,
1412                                                 MGMT_OP_SET_POWERED, 0 };
1413
1414 static const char set_link_sec_off_param[] = { 0x00 };
1415 static const char set_link_sec_off_settings_1[] = { 0x80, 0x00, 0x00, 0x00 };
1416 static const char set_link_sec_off_settings_2[] = { 0x81, 0x00, 0x00, 0x00 };
1417 static const char set_link_sec_off_auth_enable_param[] = { 0x00 };
1418
1419 static const struct generic_data set_link_sec_off_success_test_1 = {
1420         .setup_settings = settings_link_sec,
1421         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1422         .send_param = set_link_sec_off_param,
1423         .send_len = sizeof(set_link_sec_off_param),
1424         .expect_status = MGMT_STATUS_SUCCESS,
1425         .expect_param = set_link_sec_off_settings_1,
1426         .expect_len = sizeof(set_link_sec_off_settings_1),
1427         .expect_settings_unset = MGMT_SETTING_LINK_SECURITY,
1428 };
1429
1430 static const struct generic_data set_link_sec_off_success_test_2 = {
1431         .setup_settings = settings_powered_link_sec,
1432         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1433         .send_param = set_link_sec_off_param,
1434         .send_len = sizeof(set_link_sec_off_param),
1435         .expect_status = MGMT_STATUS_SUCCESS,
1436         .expect_param = set_link_sec_off_settings_2,
1437         .expect_len = sizeof(set_link_sec_off_settings_2),
1438         .expect_settings_unset = MGMT_SETTING_LINK_SECURITY,
1439         .expect_hci_command = BT_HCI_CMD_WRITE_AUTH_ENABLE,
1440         .expect_hci_param = set_link_sec_off_auth_enable_param,
1441         .expect_hci_len = sizeof(set_link_sec_off_auth_enable_param),
1442 };
1443
1444 static uint16_t settings_ssp[] = { MGMT_OP_SET_SSP, 0 };
1445
1446 static const char set_ssp_on_param[] = { 0x01 };
1447 static const char set_ssp_invalid_param[] = { 0x02 };
1448 static const char set_ssp_garbage_param[] = { 0x01, 0x00 };
1449 static const char set_ssp_settings_param_1[] = { 0xc0, 0x00, 0x00, 0x00 };
1450 static const char set_ssp_settings_param_2[] = { 0xc1, 0x00, 0x00, 0x00 };
1451 static const char set_ssp_on_write_ssp_mode_param[] = { 0x01 };
1452
1453 static const struct generic_data set_ssp_on_success_test_1 = {
1454         .send_opcode = MGMT_OP_SET_SSP,
1455         .send_param = set_ssp_on_param,
1456         .send_len = sizeof(set_ssp_on_param),
1457         .expect_status = MGMT_STATUS_SUCCESS,
1458         .expect_param = set_ssp_settings_param_1,
1459         .expect_len = sizeof(set_ssp_settings_param_1),
1460         .expect_settings_set = MGMT_SETTING_SSP,
1461 };
1462
1463 static const struct generic_data set_ssp_on_success_test_2 = {
1464         .setup_settings = settings_powered,
1465         .send_opcode = MGMT_OP_SET_SSP,
1466         .send_param = set_ssp_on_param,
1467         .send_len = sizeof(set_ssp_on_param),
1468         .expect_status = MGMT_STATUS_SUCCESS,
1469         .expect_param = set_ssp_settings_param_2,
1470         .expect_len = sizeof(set_ssp_settings_param_2),
1471         .expect_settings_set = MGMT_SETTING_SSP,
1472         .expect_hci_command = BT_HCI_CMD_WRITE_SIMPLE_PAIRING_MODE,
1473         .expect_hci_param = set_ssp_on_write_ssp_mode_param,
1474         .expect_hci_len = sizeof(set_ssp_on_write_ssp_mode_param),
1475 };
1476
1477 static const struct generic_data set_ssp_on_success_test_3 = {
1478         .setup_settings = settings_ssp,
1479         .send_opcode = MGMT_OP_SET_POWERED,
1480         .send_param = set_powered_on_param,
1481         .send_len = sizeof(set_powered_on_param),
1482         .expect_status = MGMT_STATUS_SUCCESS,
1483         .expect_param = set_ssp_settings_param_2,
1484         .expect_len = sizeof(set_ssp_settings_param_2),
1485         .expect_settings_set = MGMT_SETTING_SSP,
1486         .expect_hci_command = BT_HCI_CMD_WRITE_SIMPLE_PAIRING_MODE,
1487         .expect_hci_param = set_ssp_on_write_ssp_mode_param,
1488         .expect_hci_len = sizeof(set_ssp_on_write_ssp_mode_param),
1489 };
1490
1491 static const struct generic_data set_ssp_on_invalid_param_test_1 = {
1492         .send_opcode = MGMT_OP_SET_SSP,
1493         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1494 };
1495
1496 static const struct generic_data set_ssp_on_invalid_param_test_2 = {
1497         .send_opcode = MGMT_OP_SET_SSP,
1498         .send_param = set_ssp_invalid_param,
1499         .send_len = sizeof(set_ssp_invalid_param),
1500         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1501 };
1502
1503 static const struct generic_data set_ssp_on_invalid_param_test_3 = {
1504         .send_opcode = MGMT_OP_SET_SSP,
1505         .send_param = set_ssp_garbage_param,
1506         .send_len = sizeof(set_ssp_garbage_param),
1507         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1508 };
1509
1510 static const struct generic_data set_ssp_on_invalid_index_test = {
1511         .send_index_none = true,
1512         .send_opcode = MGMT_OP_SET_SSP,
1513         .send_param = set_ssp_on_param,
1514         .send_len = sizeof(set_ssp_on_param),
1515         .expect_status = MGMT_STATUS_INVALID_INDEX,
1516 };
1517
1518 static uint16_t settings_powered_ssp[] = { MGMT_OP_SET_SSP,
1519                                                 MGMT_OP_SET_POWERED, 0 };
1520
1521 static uint16_t settings_powered_sc[] = { MGMT_OP_SET_SSP,
1522                                                 MGMT_OP_SET_SECURE_CONN,
1523                                                 MGMT_OP_SET_POWERED, 0 };
1524
1525 static const char set_sc_on_param[] = { 0x01 };
1526 static const char set_sc_only_on_param[] = { 0x02 };
1527 static const char set_sc_invalid_param[] = { 0x03 };
1528 static const char set_sc_garbage_param[] = { 0x01, 0x00 };
1529 static const char set_sc_settings_param_1[] = { 0xc0, 0x08, 0x00, 0x00 };
1530 static const char set_sc_settings_param_2[] = { 0xc1, 0x08, 0x00, 0x00 };
1531 static const char set_sc_on_write_sc_support_param[] = { 0x01 };
1532
1533 static const struct generic_data set_sc_on_success_test_1 = {
1534         .setup_settings = settings_ssp,
1535         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1536         .send_param = set_sc_on_param,
1537         .send_len = sizeof(set_sc_on_param),
1538         .expect_status = MGMT_STATUS_SUCCESS,
1539         .expect_param = set_sc_settings_param_1,
1540         .expect_len = sizeof(set_sc_settings_param_1),
1541         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1542 };
1543
1544 static const struct generic_data set_sc_on_success_test_2 = {
1545         .setup_settings = settings_powered_ssp,
1546         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1547         .send_param = set_sc_on_param,
1548         .send_len = sizeof(set_sc_on_param),
1549         .expect_status = MGMT_STATUS_SUCCESS,
1550         .expect_param = set_sc_settings_param_2,
1551         .expect_len = sizeof(set_sc_settings_param_2),
1552         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1553         .expect_hci_command = BT_HCI_CMD_WRITE_SECURE_CONN_SUPPORT,
1554         .expect_hci_param = set_sc_on_write_sc_support_param,
1555         .expect_hci_len = sizeof(set_sc_on_write_sc_support_param),
1556 };
1557
1558 static const struct generic_data set_sc_on_invalid_param_test_1 = {
1559         .setup_settings = settings_ssp,
1560         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1561         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1562 };
1563
1564 static const struct generic_data set_sc_on_invalid_param_test_2 = {
1565         .setup_settings = settings_ssp,
1566         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1567         .send_param = set_sc_invalid_param,
1568         .send_len = sizeof(set_sc_invalid_param),
1569         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1570 };
1571
1572 static const struct generic_data set_sc_on_invalid_param_test_3 = {
1573         .setup_settings = settings_ssp,
1574         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1575         .send_param = set_sc_garbage_param,
1576         .send_len = sizeof(set_sc_garbage_param),
1577         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1578 };
1579
1580 static const struct generic_data set_sc_on_invalid_index_test = {
1581         .setup_settings = settings_ssp,
1582         .send_index_none = true,
1583         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1584         .send_param = set_sc_on_param,
1585         .send_len = sizeof(set_sc_on_param),
1586         .expect_status = MGMT_STATUS_INVALID_INDEX,
1587 };
1588
1589 static const struct generic_data set_sc_on_not_supported_test_1 = {
1590         .setup_settings = settings_ssp,
1591         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1592         .send_param = set_sc_on_param,
1593         .send_len = sizeof(set_sc_on_param),
1594         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1595 };
1596
1597 static const struct generic_data set_sc_on_not_supported_test_2 = {
1598         .setup_settings = settings_powered_ssp,
1599         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1600         .send_param = set_sc_on_param,
1601         .send_len = sizeof(set_sc_on_param),
1602         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1603 };
1604
1605 static const struct generic_data set_sc_only_on_success_test_1 = {
1606         .setup_settings = settings_ssp,
1607         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1608         .send_param = set_sc_only_on_param,
1609         .send_len = sizeof(set_sc_only_on_param),
1610         .expect_status = MGMT_STATUS_SUCCESS,
1611         .expect_param = set_sc_settings_param_1,
1612         .expect_len = sizeof(set_sc_settings_param_1),
1613         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1614 };
1615
1616 static const struct generic_data set_sc_only_on_success_test_2 = {
1617         .setup_settings = settings_powered_ssp,
1618         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1619         .send_param = set_sc_only_on_param,
1620         .send_len = sizeof(set_sc_only_on_param),
1621         .expect_status = MGMT_STATUS_SUCCESS,
1622         .expect_param = set_sc_settings_param_2,
1623         .expect_len = sizeof(set_sc_settings_param_2),
1624         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1625         .expect_hci_command = BT_HCI_CMD_WRITE_SECURE_CONN_SUPPORT,
1626         .expect_hci_param = set_sc_on_write_sc_support_param,
1627         .expect_hci_len = sizeof(set_sc_on_write_sc_support_param),
1628 };
1629
1630 static const char set_hs_on_param[] = { 0x01 };
1631 static const char set_hs_invalid_param[] = { 0x02 };
1632 static const char set_hs_garbage_param[] = { 0x01, 0x00 };
1633 static const char set_hs_settings_param_1[] = { 0xc0, 0x01, 0x00, 0x00 };
1634
1635 static const struct generic_data set_hs_on_success_test = {
1636         .setup_settings = settings_ssp,
1637         .send_opcode = MGMT_OP_SET_HS,
1638         .send_param = set_hs_on_param,
1639         .send_len = sizeof(set_hs_on_param),
1640         .expect_status = MGMT_STATUS_SUCCESS,
1641         .expect_param = set_hs_settings_param_1,
1642         .expect_len = sizeof(set_hs_settings_param_1),
1643         .expect_settings_set = MGMT_SETTING_HS,
1644 };
1645
1646 static const struct generic_data set_hs_on_invalid_param_test_1 = {
1647         .setup_settings = settings_ssp,
1648         .send_opcode = MGMT_OP_SET_HS,
1649         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1650 };
1651
1652 static const struct generic_data set_hs_on_invalid_param_test_2 = {
1653         .setup_settings = settings_ssp,
1654         .send_opcode = MGMT_OP_SET_HS,
1655         .send_param = set_hs_invalid_param,
1656         .send_len = sizeof(set_hs_invalid_param),
1657         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1658 };
1659
1660 static const struct generic_data set_hs_on_invalid_param_test_3 = {
1661         .setup_settings = settings_ssp,
1662         .send_opcode = MGMT_OP_SET_HS,
1663         .send_param = set_hs_garbage_param,
1664         .send_len = sizeof(set_hs_garbage_param),
1665         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1666 };
1667
1668 static const struct generic_data set_hs_on_invalid_index_test = {
1669         .setup_settings = settings_ssp,
1670         .send_index_none = true,
1671         .send_opcode = MGMT_OP_SET_HS,
1672         .send_param = set_hs_on_param,
1673         .send_len = sizeof(set_hs_on_param),
1674         .expect_status = MGMT_STATUS_INVALID_INDEX,
1675 };
1676
1677 static uint16_t settings_le[] = { MGMT_OP_SET_LE, 0 };
1678
1679 static const char set_le_on_param[] = { 0x01 };
1680 static const char set_le_off_param[] = { 0x00 };
1681 static const char set_le_invalid_param[] = { 0x02 };
1682 static const char set_le_garbage_param[] = { 0x01, 0x00 };
1683 static const char set_le_settings_param_1[] = { 0x80, 0x02, 0x00, 0x00 };
1684 static const char set_le_settings_param_2[] = { 0x81, 0x02, 0x00, 0x00 };
1685 static const char set_le_on_write_le_host_param[] = { 0x01, 0x00 };
1686
1687 static const struct generic_data set_le_on_success_test_1 = {
1688         .send_opcode = MGMT_OP_SET_LE,
1689         .send_param = set_le_on_param,
1690         .send_len = sizeof(set_le_on_param),
1691         .expect_status = MGMT_STATUS_SUCCESS,
1692         .expect_param = set_le_settings_param_1,
1693         .expect_len = sizeof(set_le_settings_param_1),
1694         .expect_settings_set = MGMT_SETTING_LE,
1695 };
1696
1697 static const struct generic_data set_le_on_success_test_2 = {
1698         .setup_settings = settings_powered,
1699         .send_opcode = MGMT_OP_SET_LE,
1700         .send_param = set_le_on_param,
1701         .send_len = sizeof(set_le_on_param),
1702         .expect_status = MGMT_STATUS_SUCCESS,
1703         .expect_param = set_le_settings_param_2,
1704         .expect_len = sizeof(set_le_settings_param_2),
1705         .expect_settings_set = MGMT_SETTING_LE,
1706         .expect_hci_command = BT_HCI_CMD_WRITE_LE_HOST_SUPPORTED,
1707         .expect_hci_param = set_le_on_write_le_host_param,
1708         .expect_hci_len = sizeof(set_le_on_write_le_host_param),
1709 };
1710
1711 static const struct generic_data set_le_on_success_test_3 = {
1712         .setup_settings = settings_le,
1713         .send_opcode = MGMT_OP_SET_POWERED,
1714         .send_param = set_powered_on_param,
1715         .send_len = sizeof(set_powered_on_param),
1716         .expect_status = MGMT_STATUS_SUCCESS,
1717         .expect_param = set_le_settings_param_2,
1718         .expect_len = sizeof(set_le_settings_param_2),
1719         .expect_settings_set = MGMT_SETTING_LE,
1720         .expect_hci_command = BT_HCI_CMD_WRITE_LE_HOST_SUPPORTED,
1721         .expect_hci_param = set_le_on_write_le_host_param,
1722         .expect_hci_len = sizeof(set_le_on_write_le_host_param),
1723 };
1724
1725 static const struct generic_data set_le_on_invalid_param_test_1 = {
1726         .send_opcode = MGMT_OP_SET_LE,
1727         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1728 };
1729
1730 static const struct generic_data set_le_on_invalid_param_test_2 = {
1731         .send_opcode = MGMT_OP_SET_LE,
1732         .send_param = set_le_invalid_param,
1733         .send_len = sizeof(set_le_invalid_param),
1734         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1735 };
1736
1737 static const struct generic_data set_le_on_invalid_param_test_3 = {
1738         .send_opcode = MGMT_OP_SET_LE,
1739         .send_param = set_le_garbage_param,
1740         .send_len = sizeof(set_le_garbage_param),
1741         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1742 };
1743
1744 static const struct generic_data set_le_on_invalid_index_test = {
1745         .send_index_none = true,
1746         .send_opcode = MGMT_OP_SET_LE,
1747         .send_param = set_le_on_param,
1748         .send_len = sizeof(set_le_on_param),
1749         .expect_status = MGMT_STATUS_INVALID_INDEX,
1750 };
1751
1752 static uint16_t settings_powered_le[] = { MGMT_OP_SET_LE,
1753                                         MGMT_OP_SET_POWERED, 0 };
1754
1755 static const char set_adv_on_param[] = { 0x01 };
1756 static const char set_adv_on_param2[] = { 0x02 };
1757 static const char set_adv_settings_param_1[] = { 0x80, 0x06, 0x00, 0x00 };
1758 static const char set_adv_settings_param_2[] = { 0x81, 0x06, 0x00, 0x00 };
1759 static const char set_adv_on_set_adv_enable_param[] = { 0x01 };
1760 static const char set_adv_on_set_adv_disable_param[] = { 0x00 };
1761
1762 static const struct generic_data set_adv_on_success_test_1 = {
1763         .setup_settings = settings_le,
1764         .send_opcode = MGMT_OP_SET_ADVERTISING,
1765         .send_param = set_adv_on_param,
1766         .send_len = sizeof(set_adv_on_param),
1767         .expect_status = MGMT_STATUS_SUCCESS,
1768         .expect_param = set_adv_settings_param_1,
1769         .expect_len = sizeof(set_adv_settings_param_1),
1770         .expect_settings_set = MGMT_SETTING_ADVERTISING,
1771 };
1772
1773 static const struct generic_data set_adv_on_success_test_2 = {
1774         .setup_settings = settings_powered_le,
1775         .send_opcode = MGMT_OP_SET_ADVERTISING,
1776         .send_param = set_adv_on_param,
1777         .send_len = sizeof(set_adv_on_param),
1778         .expect_status = MGMT_STATUS_SUCCESS,
1779         .expect_param = set_adv_settings_param_2,
1780         .expect_len = sizeof(set_adv_settings_param_2),
1781         .expect_settings_set = MGMT_SETTING_ADVERTISING,
1782         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
1783         .expect_hci_param = set_adv_on_set_adv_enable_param,
1784         .expect_hci_len = sizeof(set_adv_on_set_adv_enable_param),
1785 };
1786
1787 static const struct generic_data set_adv_on_rejected_test_1 = {
1788         .setup_settings = settings_powered,
1789         .send_opcode = MGMT_OP_SET_ADVERTISING,
1790         .send_param = set_adv_on_param,
1791         .send_len = sizeof(set_adv_on_param),
1792         .expect_status = MGMT_STATUS_REJECTED,
1793 };
1794
1795 static const uint8_t set_adv_set_appearance_param[2] = { 0x54, 0x65 };
1796
1797 static const uint8_t set_adv_scan_rsp_data_appear_1[] = {
1798         0x04, /* Scan rsp data len */
1799         0x03, /* Local name data len */
1800         0x19, /* Complete name */
1801         0x54, 0x65,
1802         /* padding */
1803         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1804         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1805         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1806 };
1807
1808 static const struct generic_data set_adv_on_appearance_test_1 = {
1809         .setup_settings = settings_powered_le,
1810         .setup_send_opcode = MGMT_OP_SET_APPEARANCE,
1811         .setup_send_param = set_adv_set_appearance_param,
1812         .setup_send_len = sizeof(set_adv_set_appearance_param),
1813         .send_opcode = MGMT_OP_SET_ADVERTISING,
1814         .send_param = set_adv_on_param,
1815         .expect_param = set_adv_settings_param_2,
1816         .expect_len = sizeof(set_adv_settings_param_2),
1817         .send_len = sizeof(set_adv_on_param),
1818         .expect_status = MGMT_STATUS_SUCCESS,
1819         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
1820         .expect_hci_param = set_adv_scan_rsp_data_appear_1,
1821         .expect_hci_len = sizeof(set_adv_scan_rsp_data_appear_1),
1822 };
1823
1824 static const char set_adv_set_local_name_param[260] = { 'T', 'e', 's', 't', ' ',
1825                                                         'n', 'a', 'm', 'e' };
1826
1827 static const uint8_t set_adv_scan_rsp_data_name_1[] = {
1828         0x0c, /* Scan rsp data len */
1829         0x0b, /* Local name data len */
1830         0x09, /* Complete name */
1831         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, /* "Test name" */
1832         0x00, /* null */
1833         /* padding */
1834         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1835         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1836 };
1837
1838 static const struct generic_data set_adv_on_local_name_test_1 = {
1839         .setup_settings = settings_powered_le,
1840         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
1841         .setup_send_param = set_adv_set_local_name_param,
1842         .setup_send_len = sizeof(set_adv_set_local_name_param),
1843         .send_opcode = MGMT_OP_SET_ADVERTISING,
1844         .send_param = set_adv_on_param,
1845         .expect_param = set_adv_settings_param_2,
1846         .expect_len = sizeof(set_adv_settings_param_2),
1847         .send_len = sizeof(set_adv_on_param),
1848         .expect_status = MGMT_STATUS_SUCCESS,
1849         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
1850         .expect_hci_param = set_adv_scan_rsp_data_name_1,
1851         .expect_hci_len = sizeof(set_adv_scan_rsp_data_name_1),
1852 };
1853
1854 static const struct setup_mgmt_cmd set_advertising_mgmt_cmd_arr[] = {
1855         {
1856                 .send_opcode = MGMT_OP_SET_APPEARANCE,
1857                 .send_param = set_adv_set_appearance_param,
1858                 .send_len = sizeof(set_adv_set_appearance_param),
1859         },
1860         {
1861                 .send_opcode = MGMT_OP_SET_LOCAL_NAME,
1862                 .send_param = set_adv_set_local_name_param,
1863                 .send_len = sizeof(set_adv_set_local_name_param),
1864         },
1865         { /* last element should always have opcode 0x00 */
1866                 .send_opcode = 0x00,
1867                 .send_param = NULL,
1868                 .send_len = 0,
1869         }
1870 };
1871
1872 static const uint8_t set_adv_scan_rsp_data_name_and_appearance[] = {
1873         0x10, /* scan rsp data len */
1874         0x03, /* appearance data len */
1875         0x19, /* eir_appearance */
1876         0x54, 0x65, /* appearance value */
1877         0x0b, /* local name data len */
1878         0x09, /* complete name */
1879         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, /* "test name" */
1880         0x00, /* null */
1881         /* padding */
1882         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1883         0x00, 0x00, 0x00, 0x00, 0x00,
1884 };
1885
1886
1887 static const struct generic_data set_adv_on_local_name_appear_test_1 = {
1888         .setup_settings = settings_powered_le,
1889         .setup_mgmt_cmd_arr = set_advertising_mgmt_cmd_arr,
1890         .send_opcode = MGMT_OP_SET_ADVERTISING,
1891         .send_param = set_adv_on_param,
1892         .expect_param = set_adv_settings_param_2,
1893         .expect_len = sizeof(set_adv_settings_param_2),
1894         .send_len = sizeof(set_adv_on_param),
1895         .expect_status = MGMT_STATUS_SUCCESS,
1896         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
1897         .expect_hci_param = set_adv_scan_rsp_data_name_and_appearance,
1898         .expect_hci_len = sizeof(set_adv_scan_rsp_data_name_and_appearance),
1899 };
1900
1901 static const char set_bredr_off_param[] = { 0x00 };
1902 static const char set_bredr_on_param[] = { 0x01 };
1903 static const char set_bredr_invalid_param[] = { 0x02 };
1904 static const char set_bredr_settings_param_1[] = { 0x00, 0x02, 0x00, 0x00 };
1905 static const char set_bredr_settings_param_2[] = { 0x80, 0x02, 0x00, 0x00 };
1906 static const char set_bredr_settings_param_3[] = { 0x81, 0x02, 0x00, 0x00 };
1907
1908 static const struct generic_data set_bredr_off_success_test_1 = {
1909         .setup_settings = settings_le,
1910         .send_opcode = MGMT_OP_SET_BREDR,
1911         .send_param = set_bredr_off_param,
1912         .send_len = sizeof(set_bredr_off_param),
1913         .expect_status = MGMT_STATUS_SUCCESS,
1914         .expect_param = set_bredr_settings_param_1,
1915         .expect_len = sizeof(set_bredr_settings_param_1),
1916         .expect_settings_unset = MGMT_SETTING_BREDR,
1917 };
1918
1919 static const struct generic_data set_bredr_on_success_test_1 = {
1920         .setup_settings = settings_le,
1921         .setup_nobredr = true,
1922         .send_opcode = MGMT_OP_SET_BREDR,
1923         .send_param = set_bredr_on_param,
1924         .send_len = sizeof(set_bredr_on_param),
1925         .expect_status = MGMT_STATUS_SUCCESS,
1926         .expect_param = set_bredr_settings_param_2,
1927         .expect_len = sizeof(set_bredr_settings_param_2),
1928         .expect_settings_set = MGMT_SETTING_BREDR,
1929 };
1930
1931 static const struct generic_data set_bredr_on_success_test_2 = {
1932         .setup_settings = settings_powered_le,
1933         .setup_nobredr = true,
1934         .send_opcode = MGMT_OP_SET_BREDR,
1935         .send_param = set_bredr_on_param,
1936         .send_len = sizeof(set_bredr_on_param),
1937         .expect_status = MGMT_STATUS_SUCCESS,
1938         .expect_param = set_bredr_settings_param_3,
1939         .expect_len = sizeof(set_bredr_settings_param_3),
1940         .expect_settings_set = MGMT_SETTING_BREDR,
1941 };
1942
1943 static const struct generic_data set_bredr_off_notsupp_test = {
1944         .send_opcode = MGMT_OP_SET_BREDR,
1945         .send_param = set_bredr_off_param,
1946         .send_len = sizeof(set_bredr_off_param),
1947         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1948 };
1949
1950 static const struct generic_data set_bredr_off_failure_test_1 = {
1951         .setup_settings = settings_powered_le,
1952         .send_opcode = MGMT_OP_SET_BREDR,
1953         .send_param = set_bredr_off_param,
1954         .send_len = sizeof(set_bredr_off_param),
1955         .expect_status = MGMT_STATUS_REJECTED,
1956 };
1957
1958 static const struct generic_data set_bredr_off_failure_test_2 = {
1959         .setup_settings = settings_powered,
1960         .send_opcode = MGMT_OP_SET_BREDR,
1961         .send_param = set_bredr_off_param,
1962         .send_len = sizeof(set_bredr_off_param),
1963         .expect_status = MGMT_STATUS_REJECTED,
1964 };
1965
1966 static const struct generic_data set_bredr_off_failure_test_3 = {
1967         .setup_settings = settings_le,
1968         .send_opcode = MGMT_OP_SET_BREDR,
1969         .send_param = set_bredr_invalid_param,
1970         .send_len = sizeof(set_bredr_invalid_param),
1971         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1972 };
1973
1974 static const char set_local_name_param[260] = { 'T', 'e', 's', 't', ' ',
1975                                                 'n', 'a', 'm', 'e' };
1976 static const char write_local_name_hci[248] = { 'T', 'e', 's', 't', ' ',
1977                                                 'n', 'a', 'm', 'e' };
1978 static const char write_eir_local_name_hci_1[241] = { 0x00,
1979                 0x0a, 0x09, 'T', 'e', 's', 't', ' ', 'n', 'a', 'm', 'e',
1980                 0x02, 0x0a, 0x00, };
1981
1982 static const struct mgmt_cp_set_local_name set_local_name_cp = {
1983         .name = {'T', 'e', 's', 't', ' ', 'n', 'a', 'm', 'e'},
1984         .short_name = {'T', 'e', 's', 't'},
1985 };
1986
1987 static const struct mgmt_cp_set_local_name set_local_name_longer_cp = {
1988         .name = {'T', 'e', 's', 't', ' ', 'n', 'a', 'm', 'e', '1', '2', '3'},
1989 };
1990
1991 static const struct mgmt_cp_set_local_name set_local_name_long_short_cp = {
1992         .name = {'T', 'e', 's', 't', ' ', 'n', 'a', 'm', 'e', '1', '2', '3'},
1993         .short_name = {'T', 'e', 's', 't'},
1994 };
1995
1996 static const struct generic_data set_local_name_test_1 = {
1997         .send_opcode = MGMT_OP_SET_LOCAL_NAME,
1998         .send_param = set_local_name_param,
1999         .send_len = sizeof(set_local_name_param),
2000         .expect_status = MGMT_STATUS_SUCCESS,
2001         .expect_param = set_local_name_param,
2002         .expect_len = sizeof(set_local_name_param),
2003         .expect_alt_ev = MGMT_EV_LOCAL_NAME_CHANGED,
2004         .expect_alt_ev_param = set_local_name_param,
2005         .expect_alt_ev_len = sizeof(set_local_name_param),
2006 };
2007
2008 static const struct generic_data set_local_name_test_2 = {
2009         .setup_settings = settings_powered,
2010         .send_opcode = MGMT_OP_SET_LOCAL_NAME,
2011         .send_param = set_local_name_param,
2012         .send_len = sizeof(set_local_name_param),
2013         .expect_status = MGMT_STATUS_SUCCESS,
2014         .expect_param = set_local_name_param,
2015         .expect_len = sizeof(set_local_name_param),
2016         .expect_hci_command = BT_HCI_CMD_WRITE_LOCAL_NAME,
2017         .expect_hci_param = write_local_name_hci,
2018         .expect_hci_len = sizeof(write_local_name_hci),
2019         .expect_alt_ev = MGMT_EV_LOCAL_NAME_CHANGED,
2020         .expect_alt_ev_param = set_local_name_param,
2021         .expect_alt_ev_len = sizeof(set_local_name_param),
2022 };
2023
2024 static const struct generic_data set_local_name_test_3 = {
2025         .setup_settings = settings_powered_ssp,
2026         .send_opcode = MGMT_OP_SET_LOCAL_NAME,
2027         .send_param = set_local_name_param,
2028         .send_len = sizeof(set_local_name_param),
2029         .expect_status = MGMT_STATUS_SUCCESS,
2030         .expect_param = set_local_name_param,
2031         .expect_len = sizeof(set_local_name_param),
2032         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2033         .expect_hci_param = write_eir_local_name_hci_1,
2034         .expect_hci_len = sizeof(write_eir_local_name_hci_1),
2035         .expect_alt_ev = MGMT_EV_LOCAL_NAME_CHANGED,
2036         .expect_alt_ev_param = set_local_name_param,
2037         .expect_alt_ev_len = sizeof(set_local_name_param),
2038 };
2039
2040 static const char start_discovery_invalid_param[] = { 0x00 };
2041 static const char start_discovery_bredr_param[] = { 0x01 };
2042 static const char start_discovery_le_param[] = { 0x06 };
2043 static const char start_discovery_bredrle_param[] = { 0x07 };
2044 static const char start_discovery_valid_hci[] = { 0x01, 0x01 };
2045 static const char start_discovery_evt[] = { 0x07, 0x01 };
2046 static const char start_discovery_le_evt[] = { 0x06, 0x01 };
2047
2048 static const struct generic_data start_discovery_not_powered_test_1 = {
2049         .send_opcode = MGMT_OP_START_DISCOVERY,
2050         .send_param = start_discovery_bredr_param,
2051         .send_len = sizeof(start_discovery_bredr_param),
2052         .expect_status = MGMT_STATUS_NOT_POWERED,
2053         .expect_param = start_discovery_bredr_param,
2054         .expect_len = sizeof(start_discovery_bredr_param),
2055 };
2056
2057 static const struct generic_data start_discovery_invalid_param_test_1 = {
2058         .setup_settings = settings_powered,
2059         .send_opcode = MGMT_OP_START_DISCOVERY,
2060         .send_param = start_discovery_invalid_param,
2061         .send_len = sizeof(start_discovery_invalid_param),
2062         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2063         .expect_param = start_discovery_invalid_param,
2064         .expect_len = sizeof(start_discovery_invalid_param),
2065 };
2066
2067 static const struct generic_data start_discovery_not_supported_test_1 = {
2068         .setup_settings = settings_powered,
2069         .send_opcode = MGMT_OP_START_DISCOVERY,
2070         .send_param = start_discovery_le_param,
2071         .send_len = sizeof(start_discovery_le_param),
2072         .expect_status = MGMT_STATUS_REJECTED,
2073         .expect_param = start_discovery_le_param,
2074         .expect_len = sizeof(start_discovery_le_param),
2075 };
2076
2077 static const struct generic_data start_discovery_valid_param_test_1 = {
2078         .setup_settings = settings_powered_le,
2079         .send_opcode = MGMT_OP_START_DISCOVERY,
2080         .send_param = start_discovery_bredrle_param,
2081         .send_len = sizeof(start_discovery_bredrle_param),
2082         .expect_status = MGMT_STATUS_SUCCESS,
2083         .expect_param = start_discovery_bredrle_param,
2084         .expect_len = sizeof(start_discovery_bredrle_param),
2085         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2086         .expect_hci_param = start_discovery_valid_hci,
2087         .expect_hci_len = sizeof(start_discovery_valid_hci),
2088         .expect_alt_ev = MGMT_EV_DISCOVERING,
2089         .expect_alt_ev_param = start_discovery_evt,
2090         .expect_alt_ev_len = sizeof(start_discovery_evt),
2091 };
2092
2093 static const struct generic_data start_discovery_valid_param_test_2 = {
2094         .setup_settings = settings_powered,
2095         .send_opcode = MGMT_OP_START_DISCOVERY,
2096         .send_param = start_discovery_le_param,
2097         .send_len = sizeof(start_discovery_le_param),
2098         .expect_status = MGMT_STATUS_SUCCESS,
2099         .expect_param = start_discovery_le_param,
2100         .expect_len = sizeof(start_discovery_le_param),
2101         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2102         .expect_hci_param = start_discovery_valid_hci,
2103         .expect_hci_len = sizeof(start_discovery_valid_hci),
2104         .expect_alt_ev = MGMT_EV_DISCOVERING,
2105         .expect_alt_ev_param = start_discovery_le_evt,
2106         .expect_alt_ev_len = sizeof(start_discovery_le_evt),
2107 };
2108
2109 static const struct generic_data start_discovery_valid_param_power_off_1 = {
2110         .setup_settings = settings_le,
2111         .send_opcode = MGMT_OP_START_DISCOVERY,
2112         .send_param = start_discovery_bredrle_param,
2113         .send_len = sizeof(start_discovery_bredrle_param),
2114         .expect_status = MGMT_STATUS_NOT_POWERED,
2115         .force_power_off = true,
2116         .expect_param = start_discovery_bredrle_param,
2117         .expect_len = sizeof(start_discovery_bredrle_param),
2118 };
2119
2120 static const char stop_discovery_bredrle_param[] = { 0x07 };
2121 static const char stop_discovery_bredrle_invalid_param[] = { 0x06 };
2122 static const char stop_discovery_valid_hci[] = { 0x00, 0x00 };
2123 static const char stop_discovery_evt[] = { 0x07, 0x00 };
2124 static const char stop_discovery_bredr_param[] = { 0x01 };
2125 static const char stop_discovery_bredr_discovering[] = { 0x01, 0x00 };
2126
2127 static const struct generic_data stop_discovery_success_test_1 = {
2128         .setup_settings = settings_powered_le,
2129         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
2130         .setup_send_param = start_discovery_bredrle_param,
2131         .setup_send_len = sizeof(start_discovery_bredrle_param),
2132         .send_opcode = MGMT_OP_STOP_DISCOVERY,
2133         .send_param = stop_discovery_bredrle_param,
2134         .send_len = sizeof(stop_discovery_bredrle_param),
2135         .expect_status = MGMT_STATUS_SUCCESS,
2136         .expect_param = stop_discovery_bredrle_param,
2137         .expect_len = sizeof(stop_discovery_bredrle_param),
2138         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2139         .expect_hci_param = stop_discovery_valid_hci,
2140         .expect_hci_len = sizeof(stop_discovery_valid_hci),
2141         .expect_alt_ev = MGMT_EV_DISCOVERING,
2142         .expect_alt_ev_param = stop_discovery_evt,
2143         .expect_alt_ev_len = sizeof(stop_discovery_evt),
2144 };
2145
2146 static const struct generic_data stop_discovery_bredr_success_test_1 = {
2147         .setup_settings = settings_powered,
2148         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
2149         .setup_send_param = start_discovery_bredr_param,
2150         .setup_send_len = sizeof(start_discovery_bredr_param),
2151         .send_opcode = MGMT_OP_STOP_DISCOVERY,
2152         .send_param = stop_discovery_bredr_param,
2153         .send_len = sizeof(stop_discovery_bredr_param),
2154         .expect_status = MGMT_STATUS_SUCCESS,
2155         .expect_param = stop_discovery_bredr_param,
2156         .expect_len = sizeof(stop_discovery_bredr_param),
2157         .expect_hci_command = BT_HCI_CMD_INQUIRY_CANCEL,
2158         .expect_alt_ev = MGMT_EV_DISCOVERING,
2159         .expect_alt_ev_param = stop_discovery_bredr_discovering,
2160         .expect_alt_ev_len = sizeof(stop_discovery_bredr_discovering),
2161 };
2162
2163 static const struct generic_data stop_discovery_rejected_test_1 = {
2164         .setup_settings = settings_powered_le,
2165         .send_opcode = MGMT_OP_STOP_DISCOVERY,
2166         .send_param = stop_discovery_bredrle_param,
2167         .send_len = sizeof(stop_discovery_bredrle_param),
2168         .expect_status = MGMT_STATUS_REJECTED,
2169         .expect_param = stop_discovery_bredrle_param,
2170         .expect_len = sizeof(stop_discovery_bredrle_param),
2171 };
2172
2173 static const struct generic_data stop_discovery_invalid_param_test_1 = {
2174         .setup_settings = settings_powered_le,
2175         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
2176         .setup_send_param = start_discovery_bredrle_param,
2177         .setup_send_len = sizeof(start_discovery_bredrle_param),
2178         .send_opcode = MGMT_OP_STOP_DISCOVERY,
2179         .send_param = stop_discovery_bredrle_invalid_param,
2180         .send_len = sizeof(stop_discovery_bredrle_invalid_param),
2181         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2182         .expect_param = stop_discovery_bredrle_invalid_param,
2183         .expect_len = sizeof(stop_discovery_bredrle_invalid_param),
2184 };
2185
2186 static const char start_service_discovery_invalid_param[] = { 0x00, 0x00, 0x00, 0x00 };
2187 static const char start_service_discovery_invalid_resp[] = { 0x00 };
2188 static const char start_service_discovery_bredr_param[] = { 0x01, 0x00, 0x00, 0x00};
2189 static const char start_service_discovery_bredr_resp[] = { 0x01 };
2190 static const char start_service_discovery_le_param[] = { 0x06, 0x00, 0x01, 0x00,
2191                         0xfa, 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00,
2192                         0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 };
2193 static const char start_service_discovery_le_resp[] = { 0x06 };
2194 static const char start_service_discovery_bredrle_param[] = { 0x07, 0x00, 0x01, 0x00,
2195                         0xfa, 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00,
2196                         0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 };
2197 static const char start_service_discovery_bredrle_resp[] = { 0x07 };
2198 static const char start_service_discovery_valid_hci[] = { 0x01, 0x01 };
2199 static const char start_service_discovery_evt[] = { 0x07, 0x01 };
2200 static const char start_service_discovery_le_evt[] = { 0x06, 0x01 };
2201
2202 static const struct generic_data start_service_discovery_not_powered_test_1 = {
2203         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2204         .send_param = start_service_discovery_bredr_param,
2205         .send_len = sizeof(start_service_discovery_bredr_param),
2206         .expect_status = MGMT_STATUS_NOT_POWERED,
2207         .expect_param = start_service_discovery_bredr_resp,
2208         .expect_len = sizeof(start_service_discovery_bredr_resp),
2209 };
2210
2211 static const struct generic_data start_service_discovery_invalid_param_test_1 = {
2212         .setup_settings = settings_powered,
2213         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2214         .send_param = start_service_discovery_invalid_param,
2215         .send_len = sizeof(start_service_discovery_invalid_param),
2216         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2217         .expect_param = start_service_discovery_invalid_resp,
2218         .expect_len = sizeof(start_service_discovery_invalid_resp),
2219 };
2220
2221 static const struct generic_data start_service_discovery_not_supported_test_1 = {
2222         .setup_settings = settings_powered,
2223         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2224         .send_param = start_service_discovery_le_param,
2225         .send_len = sizeof(start_service_discovery_le_param),
2226         .expect_status = MGMT_STATUS_REJECTED,
2227         .expect_param = start_service_discovery_le_resp,
2228         .expect_len = sizeof(start_service_discovery_le_resp),
2229 };
2230
2231 static const struct generic_data start_service_discovery_valid_param_test_1 = {
2232         .setup_settings = settings_powered_le,
2233         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2234         .send_param = start_service_discovery_bredrle_param,
2235         .send_len = sizeof(start_service_discovery_bredrle_param),
2236         .expect_status = MGMT_STATUS_SUCCESS,
2237         .expect_param = start_service_discovery_bredrle_resp,
2238         .expect_len = sizeof(start_service_discovery_bredrle_resp),
2239         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2240         .expect_hci_param = start_service_discovery_valid_hci,
2241         .expect_hci_len = sizeof(start_service_discovery_valid_hci),
2242         .expect_alt_ev = MGMT_EV_DISCOVERING,
2243         .expect_alt_ev_param = start_service_discovery_evt,
2244         .expect_alt_ev_len = sizeof(start_service_discovery_evt),
2245 };
2246
2247 static const struct generic_data start_service_discovery_valid_param_test_2 = {
2248         .setup_settings = settings_powered,
2249         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2250         .send_param = start_service_discovery_le_param,
2251         .send_len = sizeof(start_service_discovery_le_param),
2252         .expect_status = MGMT_STATUS_SUCCESS,
2253         .expect_param = start_service_discovery_le_resp,
2254         .expect_len = sizeof(start_service_discovery_le_resp),
2255         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2256         .expect_hci_param = start_service_discovery_valid_hci,
2257         .expect_hci_len = sizeof(start_service_discovery_valid_hci),
2258         .expect_alt_ev = MGMT_EV_DISCOVERING,
2259         .expect_alt_ev_param = start_service_discovery_le_evt,
2260         .expect_alt_ev_len = sizeof(start_service_discovery_le_evt),
2261 };
2262
2263 static const char set_dev_class_valid_param[] = { 0x01, 0x0c };
2264 static const char set_dev_class_zero_rsp[] = { 0x00, 0x00, 0x00 };
2265 static const char set_dev_class_valid_rsp[] = { 0x0c, 0x01, 0x00 };
2266 static const char set_dev_class_valid_hci[] = { 0x0c, 0x01, 0x00 };
2267 static const char set_dev_class_invalid_param[] = { 0x01, 0x01 };
2268
2269 static const struct generic_data set_dev_class_valid_param_test_1 = {
2270         .send_opcode = MGMT_OP_SET_DEV_CLASS,
2271         .send_param = set_dev_class_valid_param,
2272         .send_len = sizeof(set_dev_class_valid_param),
2273         .expect_status = MGMT_STATUS_SUCCESS,
2274         .expect_param = set_dev_class_zero_rsp,
2275         .expect_len = sizeof(set_dev_class_zero_rsp),
2276 };
2277
2278 static const struct generic_data set_dev_class_valid_param_test_2 = {
2279         .setup_settings = settings_powered,
2280         .send_opcode = MGMT_OP_SET_DEV_CLASS,
2281         .send_param = set_dev_class_valid_param,
2282         .send_len = sizeof(set_dev_class_valid_param),
2283         .expect_status = MGMT_STATUS_SUCCESS,
2284         .expect_param = set_dev_class_valid_rsp,
2285         .expect_len = sizeof(set_dev_class_valid_rsp),
2286         .expect_alt_ev = MGMT_EV_CLASS_OF_DEV_CHANGED,
2287         .expect_alt_ev_param = set_dev_class_valid_rsp,
2288         .expect_alt_ev_len = sizeof(set_dev_class_valid_rsp),
2289         .expect_hci_command = BT_HCI_CMD_WRITE_CLASS_OF_DEV,
2290         .expect_hci_param = set_dev_class_valid_hci,
2291         .expect_hci_len = sizeof(set_dev_class_valid_hci),
2292 };
2293
2294 static const struct generic_data set_dev_class_invalid_param_test_1 = {
2295         .send_opcode = MGMT_OP_SET_DEV_CLASS,
2296         .send_param = set_dev_class_invalid_param,
2297         .send_len = sizeof(set_dev_class_invalid_param),
2298         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2299 };
2300
2301 static const char add_spp_uuid_param[] = {
2302                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2303                         0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00,
2304                         0x00 };
2305 static const char add_dun_uuid_param[] = {
2306                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2307                         0x00, 0x10, 0x00, 0x00, 0x03, 0x11, 0x00, 0x00,
2308                         0x00 };
2309 static const char add_sync_uuid_param[] = {
2310                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2311                         0x00, 0x10, 0x00, 0x00, 0x04, 0x11, 0x00, 0x00,
2312                         0x00 };
2313 static const char add_opp_uuid_param[] = {
2314                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2315                         0x00, 0x10, 0x00, 0x00, 0x05, 0x11, 0x00, 0x00,
2316                         0x00 };
2317 static const char write_eir_uuid16_hci[241] = { 0x00,
2318                         0x02, 0x0a, 0x00, 0x03, 0x03, 0x01, 0x11 };
2319 static const char write_eir_multi_uuid16_hci_1[241] = { 0x00,
2320                         0x02, 0x0a, 0x00, 0x09, 0x03, 0x01, 0x11, 0x03,
2321                         0x11, 0x04, 0x11, 0x05, 0x11 };
2322 static const char write_eir_multi_uuid16_hci_2[241] = { 0x00,
2323                         0x02, 0x0a, 0x00, 0xeb, 0x02, 0x00, 0x20, 0x01,
2324                         0x20, 0x02, 0x20, 0x03, 0x20, 0x04, 0x20, 0x05,
2325                         0x20, 0x06, 0x20, 0x07, 0x20, 0x08, 0x20, 0x09,
2326                         0x20, 0x0a, 0x20, 0x0b, 0x20, 0x0c, 0x20, 0x0d,
2327                         0x20, 0x0e, 0x20, 0x0f, 0x20, 0x10, 0x20, 0x11,
2328                         0x20, 0x12, 0x20, 0x13, 0x20, 0x14, 0x20, 0x15,
2329                         0x20, 0x16, 0x20, 0x17, 0x20, 0x18, 0x20, 0x19,
2330                         0x20, 0x1a, 0x20, 0x1b, 0x20, 0x1c, 0x20, 0x1d,
2331                         0x20, 0x1e, 0x20, 0x1f, 0x20, 0x20, 0x20, 0x21,
2332                         0x20, 0x22, 0x20, 0x23, 0x20, 0x24, 0x20, 0x25,
2333                         0x20, 0x26, 0x20, 0x27, 0x20, 0x28, 0x20, 0x29,
2334                         0x20, 0x2a, 0x20, 0x2b, 0x20, 0x2c, 0x20, 0x2d,
2335                         0x20, 0x2e, 0x20, 0x2f, 0x20, 0x30, 0x20, 0x31,
2336                         0x20, 0x32, 0x20, 0x33, 0x20, 0x34, 0x20, 0x35,
2337                         0x20, 0x36, 0x20, 0x37, 0x20, 0x38, 0x20, 0x39,
2338                         0x20, 0x3a, 0x20, 0x3b, 0x20, 0x3c, 0x20, 0x3d,
2339                         0x20, 0x3e, 0x20, 0x3f, 0x20, 0x40, 0x20, 0x41,
2340                         0x20, 0x42, 0x20, 0x43, 0x20, 0x44, 0x20, 0x45,
2341                         0x20, 0x46, 0x20, 0x47, 0x20, 0x48, 0x20, 0x49,
2342                         0x20, 0x4a, 0x20, 0x4b, 0x20, 0x4c, 0x20, 0x4d,
2343                         0x20, 0x4e, 0x20, 0x4f, 0x20, 0x50, 0x20, 0x51,
2344                         0x20, 0x52, 0x20, 0x53, 0x20, 0x54, 0x20, 0x55,
2345                         0x20, 0x56, 0x20, 0x57, 0x20, 0x58, 0x20, 0x59,
2346                         0x20, 0x5a, 0x20, 0x5b, 0x20, 0x5c, 0x20, 0x5d,
2347                         0x20, 0x5e, 0x20, 0x5f, 0x20, 0x60, 0x20, 0x61,
2348                         0x20, 0x62, 0x20, 0x63, 0x20, 0x64, 0x20, 0x65,
2349                         0x20, 0x66, 0x20, 0x67, 0x20, 0x68, 0x20, 0x69,
2350                         0x20, 0x6a, 0x20, 0x6b, 0x20, 0x6c, 0x20, 0x6d,
2351                         0x20, 0x6e, 0x20, 0x6f, 0x20, 0x70, 0x20, 0x71,
2352                         0x20, 0x72, 0x20, 0x73, 0x20, 0x74, 0x20, 0x00 };
2353 static const char add_uuid32_param_1[] = {
2354                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2355                         0x00, 0x10, 0x00, 0x00, 0x78, 0x56, 0x34, 0x12,
2356                         0x00 };
2357 static const char add_uuid32_param_2[] = {
2358                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2359                         0x00, 0x10, 0x00, 0x00, 0xef, 0xcd, 0xbc, 0x9a,
2360                         0x00 };
2361 static const char add_uuid32_param_3[] = {
2362                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2363                         0x00, 0x10, 0x00, 0x00, 0xff, 0xee, 0xdd, 0xcc,
2364                         0x00 };
2365 static const char add_uuid32_param_4[] = {
2366                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2367                         0x00, 0x10, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44,
2368                         0x00 };
2369 static const char write_eir_uuid32_hci[241] = { 0x00,
2370                         0x02, 0x0a, 0x00, 0x05, 0x05, 0x78, 0x56, 0x34,
2371                         0x12 };
2372 static const char write_eir_uuid32_multi_hci[241] = { 0x00,
2373                         0x02, 0x0a, 0x00, 0x11, 0x05, 0x78, 0x56, 0x34,
2374                         0x12, 0xef, 0xcd, 0xbc, 0x9a, 0xff, 0xee, 0xdd,
2375                         0xcc, 0x11, 0x22, 0x33, 0x44 };
2376 static const char write_eir_uuid32_multi_hci_2[] = { 0x00,
2377                         0x02, 0x0a, 0x00, 0xe9, 0x04, 0xff, 0xff, 0xff,
2378                         0xff, 0xfe, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
2379                         0xff, 0xfc, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff,
2380                         0xff, 0xfa, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xff,
2381                         0xff, 0xf8, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff,
2382                         0xff, 0xf6, 0xff, 0xff, 0xff, 0xf5, 0xff, 0xff,
2383                         0xff, 0xf4, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff,
2384                         0xff, 0xf2, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff,
2385                         0xff, 0xf0, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff,
2386                         0xff, 0xee, 0xff, 0xff, 0xff, 0xed, 0xff, 0xff,
2387                         0xff, 0xec, 0xff, 0xff, 0xff, 0xeb, 0xff, 0xff,
2388                         0xff, 0xea, 0xff, 0xff, 0xff, 0xe9, 0xff, 0xff,
2389                         0xff, 0xe8, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xff,
2390                         0xff, 0xe6, 0xff, 0xff, 0xff, 0xe5, 0xff, 0xff,
2391                         0xff, 0xe4, 0xff, 0xff, 0xff, 0xe3, 0xff, 0xff,
2392                         0xff, 0xe2, 0xff, 0xff, 0xff, 0xe1, 0xff, 0xff,
2393                         0xff, 0xe0, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff,
2394                         0xff, 0xde, 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff,
2395                         0xff, 0xdc, 0xff, 0xff, 0xff, 0xdb, 0xff, 0xff,
2396                         0xff, 0xda, 0xff, 0xff, 0xff, 0xd9, 0xff, 0xff,
2397                         0xff, 0xd8, 0xff, 0xff, 0xff, 0xd7, 0xff, 0xff,
2398                         0xff, 0xd6, 0xff, 0xff, 0xff, 0xd5, 0xff, 0xff,
2399                         0xff, 0xd4, 0xff, 0xff, 0xff, 0xd3, 0xff, 0xff,
2400                         0xff, 0xd2, 0xff, 0xff, 0xff, 0xd1, 0xff, 0xff,
2401                         0xff, 0xd0, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff,
2402                         0xff, 0xce, 0xff, 0xff, 0xff, 0xcd, 0xff, 0xff,
2403                         0xff, 0xcc, 0xff, 0xff, 0xff, 0xcb, 0xff, 0xff,
2404                         0xff, 0xca, 0xff, 0xff, 0xff, 0xc9, 0xff, 0xff,
2405                         0xff, 0xc8, 0xff, 0xff, 0xff, 0xc7, 0xff, 0xff,
2406                         0xff, 0xc6, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00 };
2407 static const char add_uuid128_param_1[] = {
2408                         0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
2409                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
2410                         0x00 };
2411 static const char add_uuid128_param_2[] = {
2412                         0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88,
2413                         0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
2414                         0x00 };
2415 static const char write_eir_uuid128_hci[241] = { 0x00,
2416                         0x02, 0x0a, 0x00, 0x11, 0x07, 0x00, 0x11, 0x22,
2417                         0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
2418                         0xbb, 0xcc, 0xdd, 0xee, 0xff };
2419 static const char write_eir_uuid128_multi_hci[241] = { 0x00,
2420                         0x02, 0x0a, 0x00, 0x21, 0x07, 0x00, 0x11, 0x22,
2421                         0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
2422                         0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff, 0xee, 0xdd,
2423                         0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55,
2424                         0x44, 0x33, 0x22, 0x11 };
2425 static const char write_eir_uuid128_multi_hci_2[] = { 0x00,
2426                         0x02, 0x0a, 0x00, 0xe1, 0x07, 0x11, 0x22, 0x33,
2427                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2428                         0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22, 0x33,
2429                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2430                         0xcc, 0xdd, 0xee, 0xff, 0x01, 0x11, 0x22, 0x33,
2431                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2432                         0xcc, 0xdd, 0xee, 0xff, 0x02, 0x11, 0x22, 0x33,
2433                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2434                         0xcc, 0xdd, 0xee, 0xff, 0x03, 0x11, 0x22, 0x33,
2435                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2436                         0xcc, 0xdd, 0xee, 0xff, 0x04, 0x11, 0x22, 0x33,
2437                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2438                         0xcc, 0xdd, 0xee, 0xff, 0x05, 0x11, 0x22, 0x33,
2439                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2440                         0xcc, 0xdd, 0xee, 0xff, 0x06, 0x11, 0x22, 0x33,
2441                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2442                         0xcc, 0xdd, 0xee, 0xff, 0x07, 0x11, 0x22, 0x33,
2443                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2444                         0xcc, 0xdd, 0xee, 0xff, 0x08, 0x11, 0x22, 0x33,
2445                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2446                         0xcc, 0xdd, 0xee, 0xff, 0x09, 0x11, 0x22, 0x33,
2447                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2448                         0xcc, 0xdd, 0xee, 0xff, 0x0a, 0x11, 0x22, 0x33,
2449                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2450                         0xcc, 0xdd, 0xee, 0xff, 0x0b, 0x11, 0x22, 0x33,
2451                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2452                         0xcc, 0xdd, 0xee, 0xff, 0x0c, 0xff, 0xee, 0xdd,
2453                         0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55,
2454                         0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00,
2455                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
2456 static const char write_eir_uuid_mix_hci[241] = { 0x00,
2457                         0x02, 0x0a, 0x00, 0x05, 0x03, 0x01, 0x11, 0x03,
2458                         0x11, 0x09, 0x05, 0x78, 0x56, 0x34, 0x12, 0xef,
2459                         0xcd, 0xbc, 0x9a, 0x21, 0x07, 0x00, 0x11, 0x22,
2460                         0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
2461                         0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff, 0xee, 0xdd,
2462                         0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55,
2463                         0x44, 0x33, 0x22, 0x11 };
2464
2465 static const struct generic_data add_uuid16_test_1 = {
2466         .setup_settings = settings_powered_ssp,
2467         .send_opcode = MGMT_OP_ADD_UUID,
2468         .send_param = add_spp_uuid_param,
2469         .send_len = sizeof(add_spp_uuid_param),
2470         .expect_status = MGMT_STATUS_SUCCESS,
2471         .expect_param = set_dev_class_zero_rsp,
2472         .expect_len = sizeof(set_dev_class_zero_rsp),
2473         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2474         .expect_hci_param = write_eir_uuid16_hci,
2475         .expect_hci_len = sizeof(write_eir_uuid16_hci),
2476 };
2477
2478 static const struct generic_data add_multi_uuid16_test_1 = {
2479         .send_opcode = MGMT_OP_ADD_UUID,
2480         .send_param = add_opp_uuid_param,
2481         .send_len = sizeof(add_opp_uuid_param),
2482         .expect_status = MGMT_STATUS_SUCCESS,
2483         .expect_param = set_dev_class_zero_rsp,
2484         .expect_len = sizeof(set_dev_class_zero_rsp),
2485         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2486         .expect_hci_param = write_eir_multi_uuid16_hci_1,
2487         .expect_hci_len = sizeof(write_eir_multi_uuid16_hci_1),
2488 };
2489
2490 static const struct generic_data add_multi_uuid16_test_2 = {
2491         .send_opcode = MGMT_OP_ADD_UUID,
2492         .send_param = add_opp_uuid_param,
2493         .send_len = sizeof(add_opp_uuid_param),
2494         .expect_status = MGMT_STATUS_SUCCESS,
2495         .expect_param = set_dev_class_zero_rsp,
2496         .expect_len = sizeof(set_dev_class_zero_rsp),
2497         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2498         .expect_hci_param = write_eir_multi_uuid16_hci_2,
2499         .expect_hci_len = sizeof(write_eir_multi_uuid16_hci_2),
2500 };
2501
2502 static const struct generic_data add_uuid32_test_1 = {
2503         .setup_settings = settings_powered_ssp,
2504         .send_opcode = MGMT_OP_ADD_UUID,
2505         .send_param = add_uuid32_param_1,
2506         .send_len = sizeof(add_uuid32_param_1),
2507         .expect_status = MGMT_STATUS_SUCCESS,
2508         .expect_param = set_dev_class_zero_rsp,
2509         .expect_len = sizeof(set_dev_class_zero_rsp),
2510         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2511         .expect_hci_param = write_eir_uuid32_hci,
2512         .expect_hci_len = sizeof(write_eir_uuid32_hci),
2513 };
2514
2515 static const struct generic_data add_uuid32_multi_test_1 = {
2516         .send_opcode = MGMT_OP_ADD_UUID,
2517         .send_param = add_uuid32_param_4,
2518         .send_len = sizeof(add_uuid32_param_4),
2519         .expect_status = MGMT_STATUS_SUCCESS,
2520         .expect_param = set_dev_class_zero_rsp,
2521         .expect_len = sizeof(set_dev_class_zero_rsp),
2522         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2523         .expect_hci_param = write_eir_uuid32_multi_hci,
2524         .expect_hci_len = sizeof(write_eir_uuid32_multi_hci),
2525 };
2526
2527 static const struct generic_data add_uuid32_multi_test_2 = {
2528         .send_opcode = MGMT_OP_ADD_UUID,
2529         .send_param = add_uuid32_param_4,
2530         .send_len = sizeof(add_uuid32_param_4),
2531         .expect_status = MGMT_STATUS_SUCCESS,
2532         .expect_param = set_dev_class_zero_rsp,
2533         .expect_len = sizeof(set_dev_class_zero_rsp),
2534         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2535         .expect_hci_param = write_eir_uuid32_multi_hci_2,
2536         .expect_hci_len = sizeof(write_eir_uuid32_multi_hci_2),
2537 };
2538
2539 static const struct generic_data add_uuid128_test_1 = {
2540         .setup_settings = settings_powered_ssp,
2541         .send_opcode = MGMT_OP_ADD_UUID,
2542         .send_param = add_uuid128_param_1,
2543         .send_len = sizeof(add_uuid128_param_1),
2544         .expect_status = MGMT_STATUS_SUCCESS,
2545         .expect_param = set_dev_class_zero_rsp,
2546         .expect_len = sizeof(set_dev_class_zero_rsp),
2547         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2548         .expect_hci_param = write_eir_uuid128_hci,
2549         .expect_hci_len = sizeof(write_eir_uuid128_hci),
2550 };
2551
2552 static const struct generic_data add_uuid128_multi_test_1 = {
2553         .send_opcode = MGMT_OP_ADD_UUID,
2554         .send_param = add_uuid128_param_2,
2555         .send_len = sizeof(add_uuid32_param_2),
2556         .expect_status = MGMT_STATUS_SUCCESS,
2557         .expect_param = set_dev_class_zero_rsp,
2558         .expect_len = sizeof(set_dev_class_zero_rsp),
2559         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2560         .expect_hci_param = write_eir_uuid128_multi_hci,
2561         .expect_hci_len = sizeof(write_eir_uuid128_multi_hci),
2562 };
2563
2564 static const struct generic_data add_uuid128_multi_test_2 = {
2565         .send_opcode = MGMT_OP_ADD_UUID,
2566         .send_param = add_uuid128_param_2,
2567         .send_len = sizeof(add_uuid128_param_2),
2568         .expect_status = MGMT_STATUS_SUCCESS,
2569         .expect_param = set_dev_class_zero_rsp,
2570         .expect_len = sizeof(set_dev_class_zero_rsp),
2571         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2572         .expect_hci_param = write_eir_uuid128_multi_hci_2,
2573         .expect_hci_len = sizeof(write_eir_uuid128_multi_hci_2),
2574 };
2575
2576 static const struct generic_data add_uuid_mix_test_1 = {
2577         .send_opcode = MGMT_OP_ADD_UUID,
2578         .send_param = add_uuid128_param_2,
2579         .send_len = sizeof(add_uuid128_param_2),
2580         .expect_status = MGMT_STATUS_SUCCESS,
2581         .expect_param = set_dev_class_zero_rsp,
2582         .expect_len = sizeof(set_dev_class_zero_rsp),
2583         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2584         .expect_hci_param = write_eir_uuid_mix_hci,
2585         .expect_hci_len = sizeof(write_eir_uuid_mix_hci),
2586 };
2587
2588 static const char remove_dun_uuid_param[] = {
2589                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2590                         0x00, 0x10, 0x00, 0x00, 0x03, 0x11, 0x00, 0x00 };
2591
2592 static const char write_eir_remove_dun_hci[241] = {
2593                         0x00, 0x02, 0x0a, 0x00, 0x05, 0x03, 0x01, 0x11, 0x04,
2594                         0x11 };
2595
2596 static const struct generic_data remove_uuid_success_1 = {
2597         .send_opcode = MGMT_OP_REMOVE_UUID,
2598         .send_param = remove_dun_uuid_param,
2599         .send_len = sizeof(remove_dun_uuid_param),
2600         .expect_status = MGMT_STATUS_SUCCESS,
2601         .expect_param = set_dev_class_zero_rsp,
2602         .expect_len = sizeof(set_dev_class_zero_rsp),
2603         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2604         .expect_hci_param = write_eir_remove_dun_hci,
2605         .expect_hci_len = sizeof(write_eir_remove_dun_hci),
2606 };
2607
2608 static const char remove_all_uuid_param[16] = { 0x00 };
2609
2610 static const struct generic_data remove_uuid_all_success_2 = {
2611         .send_opcode = MGMT_OP_REMOVE_UUID,
2612         .send_param = remove_all_uuid_param,
2613         .send_len = sizeof(remove_all_uuid_param),
2614         .expect_status = MGMT_STATUS_SUCCESS,
2615         .expect_param = set_dev_class_zero_rsp,
2616         .expect_len = sizeof(set_dev_class_zero_rsp),
2617 };
2618
2619 static const struct generic_data remove_uuid_power_off_success_3 = {
2620         .send_opcode = MGMT_OP_REMOVE_UUID,
2621         .send_param = remove_dun_uuid_param,
2622         .send_len = sizeof(remove_dun_uuid_param),
2623         .expect_status = MGMT_STATUS_SUCCESS,
2624         .expect_param = set_dev_class_zero_rsp,
2625         .expect_len = sizeof(set_dev_class_zero_rsp),
2626 };
2627
2628 static const struct generic_data remove_uuid_power_off_on_success_4 = {
2629         .send_opcode = MGMT_OP_SET_POWERED,
2630         .send_param = set_powered_on_param,
2631         .send_len = sizeof(set_powered_on_param),
2632         .expect_status = MGMT_STATUS_SUCCESS,
2633         .expect_param = set_ssp_settings_param_2,
2634         .expect_len = sizeof(set_ssp_settings_param_2),
2635         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2636         .expect_hci_param = write_eir_remove_dun_hci,
2637         .expect_hci_len = sizeof(write_eir_remove_dun_hci),
2638 };
2639
2640 static const struct generic_data remove_uuid_invalid_params_1 = {
2641         .send_opcode = MGMT_OP_REMOVE_UUID,
2642         .send_param = add_opp_uuid_param,
2643         .send_len = sizeof(add_opp_uuid_param),
2644         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2645 };
2646
2647 static const char load_link_keys_valid_param_1[] = { 0x00, 0x00, 0x00 };
2648 static const char load_link_keys_valid_param_2[] = { 0x01, 0x00, 0x00 };
2649 static const char load_link_keys_invalid_param_1[] = { 0x02, 0x00, 0x00 };
2650 static const char load_link_keys_invalid_param_2[] = { 0x00, 0x01, 0x00 };
2651 /* Invalid bdaddr type */
2652 static const char load_link_keys_invalid_param_3[] = { 0x00, 0x01, 0x00,
2653         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* addr */
2654         0x01,                                           /* addr type */
2655         0x00,                                           /* key type */
2656         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2657         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2658         0x04,                                           /* PIN length */
2659 };
2660
2661 static const struct generic_data load_link_keys_success_test_1 = {
2662         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2663         .send_param = load_link_keys_valid_param_1,
2664         .send_len = sizeof(load_link_keys_valid_param_1),
2665         .expect_status = MGMT_STATUS_SUCCESS,
2666 };
2667
2668 static const struct generic_data load_link_keys_success_test_2 = {
2669         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2670         .send_param = load_link_keys_valid_param_2,
2671         .send_len = sizeof(load_link_keys_valid_param_2),
2672         .expect_status = MGMT_STATUS_SUCCESS,
2673 };
2674
2675 static const struct generic_data load_link_keys_invalid_params_test_1 = {
2676         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2677         .send_param = load_link_keys_invalid_param_1,
2678         .send_len = sizeof(load_link_keys_invalid_param_1),
2679         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2680 };
2681
2682 static const struct generic_data load_link_keys_invalid_params_test_2 = {
2683         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2684         .send_param = load_link_keys_invalid_param_2,
2685         .send_len = sizeof(load_link_keys_invalid_param_2),
2686         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2687 };
2688
2689 static const struct generic_data load_link_keys_invalid_params_test_3 = {
2690         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2691         .send_param = load_link_keys_invalid_param_3,
2692         .send_len = sizeof(load_link_keys_invalid_param_3),
2693         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2694 };
2695
2696 static const char load_ltks_valid_param_1[] = { 0x00, 0x00 };
2697
2698 static const char load_ltks_valid_param_2[] = {
2699         0x01, 0x00,                                     /* count */
2700         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2701         0x01,                                           /* addr type */
2702         0x00,                                           /* authenticated */
2703         0x00,                                           /* master */
2704         0x00,                                           /* encryption size */
2705         0x00, 0x00,                                     /* diversifier */
2706         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2707         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2708         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2709 };
2710
2711 /* 20 keys at once */
2712 static const char load_ltks_valid_param_20[] = {
2713         0x14, 0x00,                                     /* count */
2714         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2715         0x01,                                           /* addr type */
2716         0x00,                                           /* authenticated */
2717         0x00,                                           /* master */
2718         0x00,                                           /* encryption size */
2719         0x00, 0x00,                                     /* diversifier */
2720         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2721         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2722         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2723
2724         0x01, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2725         0x01,                                           /* addr type */
2726         0x00,                                           /* authenticated */
2727         0x00,                                           /* master */
2728         0x00,                                           /* encryption size */
2729         0x00, 0x00,                                     /* diversifier */
2730         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2731         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2732         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2733
2734         0x02, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2735         0x01,                                           /* addr type */
2736         0x00,                                           /* authenticated */
2737         0x00,                                           /* master */
2738         0x00,                                           /* encryption size */
2739         0x00, 0x00,                                     /* diversifier */
2740         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2741         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2742         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2743
2744         0x03, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2745         0x01,                                           /* addr type */
2746         0x00,                                           /* authenticated */
2747         0x00,                                           /* master */
2748         0x00,                                           /* encryption size */
2749         0x00, 0x00,                                     /* diversifier */
2750         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2751         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2752         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2753
2754         0x04, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2755         0x01,                                           /* addr type */
2756         0x00,                                           /* authenticated */
2757         0x00,                                           /* master */
2758         0x00,                                           /* encryption size */
2759         0x00, 0x00,                                     /* diversifier */
2760         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2761         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2762         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2763
2764         0x05, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2765         0x01,                                           /* addr type */
2766         0x00,                                           /* authenticated */
2767         0x00,                                           /* master */
2768         0x00,                                           /* encryption size */
2769         0x00, 0x00,                                     /* diversifier */
2770         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2771         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2772         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2773
2774         0x06, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2775         0x01,                                           /* addr type */
2776         0x00,                                           /* authenticated */
2777         0x00,                                           /* master */
2778         0x00,                                           /* encryption size */
2779         0x00, 0x00,                                     /* diversifier */
2780         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2781         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2782         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2783
2784         0x07, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2785         0x01,                                           /* addr type */
2786         0x00,                                           /* authenticated */
2787         0x00,                                           /* master */
2788         0x00,                                           /* encryption size */
2789         0x00, 0x00,                                     /* diversifier */
2790         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2791         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2792         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2793
2794         0x08, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2795         0x01,                                           /* addr type */
2796         0x00,                                           /* authenticated */
2797         0x00,                                           /* master */
2798         0x00,                                           /* encryption size */
2799         0x00, 0x00,                                     /* diversifier */
2800         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2801         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2802         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2803
2804         0x09, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2805         0x01,                                           /* addr type */
2806         0x00,                                           /* authenticated */
2807         0x00,                                           /* master */
2808         0x00,                                           /* encryption size */
2809         0x00, 0x00,                                     /* diversifier */
2810         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2811         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2812         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2813
2814         0x0a, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2815         0x01,                                           /* addr type */
2816         0x00,                                           /* authenticated */
2817         0x00,                                           /* master */
2818         0x00,                                           /* encryption size */
2819         0x00, 0x00,                                     /* diversifier */
2820         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2821         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2822         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2823
2824         0x0b, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2825         0x01,                                           /* addr type */
2826         0x00,                                           /* authenticated */
2827         0x00,                                           /* master */
2828         0x00,                                           /* encryption size */
2829         0x00, 0x00,                                     /* diversifier */
2830         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2831         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2832         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2833
2834         0x0c, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2835         0x01,                                           /* addr type */
2836         0x00,                                           /* authenticated */
2837         0x00,                                           /* master */
2838         0x00,                                           /* encryption size */
2839         0x00, 0x00,                                     /* diversifier */
2840         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2841         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2842         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2843
2844         0x0d, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2845         0x01,                                           /* addr type */
2846         0x00,                                           /* authenticated */
2847         0x00,                                           /* master */
2848         0x00,                                           /* encryption size */
2849         0x00, 0x00,                                     /* diversifier */
2850         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2851         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2852         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2853
2854         0x0e, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2855         0x01,                                           /* addr type */
2856         0x00,                                           /* authenticated */
2857         0x00,                                           /* master */
2858         0x00,                                           /* encryption size */
2859         0x00, 0x00,                                     /* diversifier */
2860         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2861         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2862         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2863
2864         0x0f, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2865         0x01,                                           /* addr type */
2866         0x00,                                           /* authenticated */
2867         0x00,                                           /* master */
2868         0x00,                                           /* encryption size */
2869         0x00, 0x00,                                     /* diversifier */
2870         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2871         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2872         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2873
2874         0x10, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2875         0x01,                                           /* addr type */
2876         0x00,                                           /* authenticated */
2877         0x00,                                           /* master */
2878         0x00,                                           /* encryption size */
2879         0x00, 0x00,                                     /* diversifier */
2880         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2881         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2882         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2883
2884         0x11, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2885         0x01,                                           /* addr type */
2886         0x00,                                           /* authenticated */
2887         0x00,                                           /* master */
2888         0x00,                                           /* encryption size */
2889         0x00, 0x00,                                     /* diversifier */
2890         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2891         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2892         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2893
2894         0x12, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2895         0x01,                                           /* addr type */
2896         0x00,                                           /* authenticated */
2897         0x00,                                           /* master */
2898         0x00,                                           /* encryption size */
2899         0x00, 0x00,                                     /* diversifier */
2900         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2901         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2902         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2903
2904         0x13, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2905         0x01,                                           /* addr type */
2906         0x00,                                           /* authenticated */
2907         0x00,                                           /* master */
2908         0x00,                                           /* encryption size */
2909         0x00, 0x00,                                     /* diversifier */
2910         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2911         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2912         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2913 };
2914
2915 /* Invalid key count */
2916 static const char load_ltks_invalid_param_1[] = { 0x01, 0x00 };
2917 /* Invalid addr type */
2918 static const char load_ltks_invalid_param_2[] = {
2919         0x01, 0x00,                                     /* count */
2920         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2921         0x00,                                           /* addr type */
2922         0x00,                                           /* authenticated */
2923         0x00,                                           /* central */
2924         0x00,                                           /* encryption size */
2925         0x00, 0x00,                                     /* diversifier */
2926         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2927         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2928         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2929 };
2930 /* Invalid central value */
2931 static const char load_ltks_invalid_param_3[] = {
2932         0x01, 0x00,                                     /* count */
2933         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2934         0x01,                                           /* addr type */
2935         0x00,                                           /* authenticated */
2936         0x02,                                           /* central */
2937         0x00,                                           /* encryption size */
2938         0x00, 0x00,                                     /* diversifier */
2939         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2940         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2941         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2942 };
2943
2944 static const struct generic_data load_ltks_success_test_1 = {
2945         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2946         .send_param = load_ltks_valid_param_1,
2947         .send_len = sizeof(load_ltks_valid_param_1),
2948         .expect_status = MGMT_STATUS_SUCCESS,
2949 };
2950
2951 static const struct generic_data load_ltks_success_test_2 = {
2952         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2953         .send_param = load_ltks_valid_param_2,
2954         .send_len = sizeof(load_ltks_valid_param_2),
2955         .expect_status = MGMT_STATUS_SUCCESS,
2956 };
2957
2958 static const struct generic_data load_ltks_success_test_3 = {
2959         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2960         .send_param = load_ltks_valid_param_2,
2961         .send_len = sizeof(load_ltks_valid_param_2),
2962         .expect_status = MGMT_STATUS_SUCCESS,
2963 };
2964
2965 static const struct generic_data load_ltks_success_test_4 = {
2966         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2967         .send_param = load_ltks_valid_param_20,
2968         .send_len = sizeof(load_ltks_valid_param_20),
2969         .expect_status = MGMT_STATUS_SUCCESS,
2970 };
2971
2972 static const struct generic_data load_ltks_success_test_5 = {
2973         .setup_settings = settings_powered_le,
2974         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2975         .send_param = load_ltks_valid_param_20,
2976         .send_len = sizeof(load_ltks_valid_param_20),
2977         .expect_status = MGMT_STATUS_SUCCESS,
2978 };
2979
2980 static const struct generic_data load_ltks_invalid_params_test_1 = {
2981         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2982         .send_param = load_ltks_invalid_param_1,
2983         .send_len = sizeof(load_ltks_invalid_param_1),
2984         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2985 };
2986
2987 static const struct generic_data load_ltks_invalid_params_test_2 = {
2988         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2989         .send_param = load_ltks_invalid_param_2,
2990         .send_len = sizeof(load_ltks_invalid_param_2),
2991         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2992 };
2993
2994 static const struct generic_data load_ltks_invalid_params_test_3 = {
2995         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2996         .send_param = load_ltks_invalid_param_3,
2997         .send_len = sizeof(load_ltks_invalid_param_3),
2998         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2999 };
3000
3001 static const char load_ltks_invalid_param_4[22] = { 0x1d, 0x07 };
3002 static const struct generic_data load_ltks_invalid_params_test_4 = {
3003         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
3004         .send_param = load_ltks_invalid_param_4,
3005         .send_len = sizeof(load_ltks_invalid_param_4),
3006         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3007 };
3008
3009 static const char set_io_cap_invalid_param_1[] = { 0xff };
3010
3011 static const struct generic_data set_io_cap_invalid_param_test_1 = {
3012         .send_opcode = MGMT_OP_SET_IO_CAPABILITY,
3013         .send_param = set_io_cap_invalid_param_1,
3014         .send_len = sizeof(set_io_cap_invalid_param_1),
3015         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3016 };
3017
3018 static const char pair_device_param[] = {
3019                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00 };
3020 static const char pair_device_rsp[] = {
3021                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
3022 static const char pair_device_invalid_param_1[] = {
3023                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff, 0x00 };
3024 static const char pair_device_invalid_param_rsp_1[] = {
3025                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3026 static const char pair_device_invalid_param_2[] = {
3027                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x05 };
3028 static const char pair_device_invalid_param_rsp_2[] = {
3029                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
3030
3031 static const struct generic_data pair_device_not_powered_test_1 = {
3032         .send_opcode = MGMT_OP_PAIR_DEVICE,
3033         .send_param = pair_device_param,
3034         .send_len = sizeof(pair_device_param),
3035         .expect_status = MGMT_STATUS_NOT_POWERED,
3036         .expect_param = pair_device_rsp,
3037         .expect_len = sizeof(pair_device_rsp),
3038 };
3039
3040 static const struct generic_data pair_device_invalid_param_test_1 = {
3041         .send_opcode = MGMT_OP_PAIR_DEVICE,
3042         .send_param = pair_device_invalid_param_1,
3043         .send_len = sizeof(pair_device_invalid_param_1),
3044         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3045         .expect_param = pair_device_invalid_param_rsp_1,
3046         .expect_len = sizeof(pair_device_invalid_param_rsp_1),
3047 };
3048
3049 static const struct generic_data pair_device_invalid_param_test_2 = {
3050         .send_opcode = MGMT_OP_PAIR_DEVICE,
3051         .send_param = pair_device_invalid_param_2,
3052         .send_len = sizeof(pair_device_invalid_param_2),
3053         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3054         .expect_param = pair_device_invalid_param_rsp_2,
3055         .expect_len = sizeof(pair_device_invalid_param_rsp_2),
3056 };
3057
3058 static const void *pair_device_send_param_func(uint16_t *len)
3059 {
3060         struct test_data *data = tester_get_data();
3061         const struct generic_data *test = data->test_data;
3062         static uint8_t param[8];
3063
3064         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3065
3066         if (test->addr_type_avail)
3067                 param[6] = test->addr_type;
3068         else if (data->hciemu_type == HCIEMU_TYPE_LE)
3069                 param[6] = 0x01; /* Address type */
3070         else
3071                 param[6] = 0x00; /* Address type */
3072         param[7] = test->io_cap;
3073
3074         *len = sizeof(param);
3075
3076         return param;
3077 }
3078
3079 static const void *pair_device_expect_param_func(uint16_t *len)
3080 {
3081         struct test_data *data = tester_get_data();
3082         const struct generic_data *test = data->test_data;
3083         static uint8_t param[7];
3084
3085         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3086
3087         if (test->addr_type_avail)
3088                 param[6] = test->addr_type;
3089         else if (data->hciemu_type == HCIEMU_TYPE_LE)
3090                 param[6] = 0x01; /* Address type */
3091         else
3092                 param[6] = 0x00; /* Address type */
3093
3094         *len = sizeof(param);
3095
3096         return param;
3097 }
3098
3099 static uint16_t settings_powered_bondable[] = { MGMT_OP_SET_BONDABLE,
3100                                                 MGMT_OP_SET_POWERED, 0 };
3101 static uint8_t auth_req_param[] = { 0x2a, 0x00 };
3102 static uint8_t pair_device_pin[] = { 0x30, 0x30, 0x30, 0x30 }; /* "0000" */
3103
3104 static const struct generic_data pair_device_success_test_1 = {
3105         .setup_settings = settings_powered_bondable,
3106         .send_opcode = MGMT_OP_PAIR_DEVICE,
3107         .send_func = pair_device_send_param_func,
3108         .expect_status = MGMT_STATUS_SUCCESS,
3109         .expect_func = pair_device_expect_param_func,
3110         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3111         .expect_alt_ev_len = 26,
3112         .expect_hci_command = BT_HCI_CMD_AUTH_REQUESTED,
3113         .expect_hci_param = auth_req_param,
3114         .expect_hci_len = sizeof(auth_req_param),
3115         .pin = pair_device_pin,
3116         .pin_len = sizeof(pair_device_pin),
3117         .client_pin = pair_device_pin,
3118         .client_pin_len = sizeof(pair_device_pin),
3119 };
3120
3121 static uint16_t settings_powered_bondable_linksec[] = { MGMT_OP_SET_BONDABLE,
3122                                                         MGMT_OP_SET_POWERED,
3123                                                         MGMT_OP_SET_LINK_SECURITY,
3124                                                         0 };
3125
3126 static const struct generic_data pair_device_success_test_2 = {
3127         .setup_settings = settings_powered_bondable_linksec,
3128         .send_opcode = MGMT_OP_PAIR_DEVICE,
3129         .send_func = pair_device_send_param_func,
3130         .expect_status = MGMT_STATUS_SUCCESS,
3131         .expect_func = pair_device_expect_param_func,
3132         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3133         .expect_alt_ev_len = 26,
3134         .expect_hci_command = BT_HCI_CMD_AUTH_REQUESTED,
3135         .expect_hci_param = auth_req_param,
3136         .expect_hci_len = sizeof(auth_req_param),
3137         .pin = pair_device_pin,
3138         .pin_len = sizeof(pair_device_pin),
3139         .client_pin = pair_device_pin,
3140         .client_pin_len = sizeof(pair_device_pin),
3141 };
3142
3143 static const struct generic_data pair_device_legacy_nonbondable_1 = {
3144         .setup_settings = settings_powered,
3145         .send_opcode = MGMT_OP_PAIR_DEVICE,
3146         .send_func = pair_device_send_param_func,
3147         .expect_status = MGMT_STATUS_SUCCESS,
3148         .expect_func = pair_device_expect_param_func,
3149         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3150         .expect_alt_ev_len = 26,
3151         .pin = pair_device_pin,
3152         .pin_len = sizeof(pair_device_pin),
3153         .client_pin = pair_device_pin,
3154         .client_pin_len = sizeof(pair_device_pin),
3155 };
3156
3157 static const struct generic_data pair_device_power_off_test_1 = {
3158         .setup_settings = settings_powered_bondable,
3159         .send_opcode = MGMT_OP_PAIR_DEVICE,
3160         .send_func = pair_device_send_param_func,
3161         .force_power_off = true,
3162         .expect_status = MGMT_STATUS_NOT_POWERED,
3163         .expect_func = pair_device_expect_param_func,
3164 };
3165
3166 static const void *client_bdaddr_param_func(uint8_t *len)
3167 {
3168         struct test_data *data = tester_get_data();
3169         static uint8_t bdaddr[6];
3170
3171         memcpy(bdaddr, hciemu_get_client_bdaddr(data->hciemu), 6);
3172
3173         *len = sizeof(bdaddr);
3174
3175         return bdaddr;
3176 }
3177
3178 static const struct generic_data pair_device_not_supported_test_1 = {
3179         .setup_settings = settings_powered_bondable,
3180         .send_opcode = MGMT_OP_PAIR_DEVICE,
3181         .send_func = pair_device_send_param_func,
3182         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
3183         .expect_func = pair_device_expect_param_func,
3184         .addr_type_avail = true,
3185         .addr_type = BDADDR_BREDR,
3186 };
3187
3188 static const struct generic_data pair_device_not_supported_test_2 = {
3189         .setup_settings = settings_powered_bondable,
3190         .send_opcode = MGMT_OP_PAIR_DEVICE,
3191         .send_func = pair_device_send_param_func,
3192         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
3193         .expect_func = pair_device_expect_param_func,
3194         .addr_type_avail = true,
3195         .addr_type = BDADDR_LE_PUBLIC,
3196 };
3197
3198 static uint16_t settings_powered_bondable_le[] = { MGMT_OP_SET_LE,
3199                                                         MGMT_OP_SET_BONDABLE,
3200                                                         MGMT_OP_SET_POWERED,
3201                                                         0 };
3202
3203 static const struct generic_data pair_device_reject_transport_not_enabled_1 = {
3204         .setup_settings = settings_powered_bondable_le,
3205         .setup_nobredr = true,
3206         .send_opcode = MGMT_OP_PAIR_DEVICE,
3207         .send_func = pair_device_send_param_func,
3208         .expect_status = MGMT_STATUS_REJECTED,
3209         .expect_func = pair_device_expect_param_func,
3210         .addr_type_avail = true,
3211         .addr_type = BDADDR_BREDR,
3212 };
3213
3214 static const struct generic_data pair_device_reject_transport_not_enabled_2 = {
3215         .setup_settings = settings_powered_bondable,
3216         .send_opcode = MGMT_OP_PAIR_DEVICE,
3217         .send_func = pair_device_send_param_func,
3218         .expect_status = MGMT_STATUS_REJECTED,
3219         .expect_func = pair_device_expect_param_func,
3220         .addr_type_avail = true,
3221         .addr_type = BDADDR_LE_PUBLIC,
3222 };
3223
3224 static const struct generic_data pair_device_reject_test_1 = {
3225         .setup_settings = settings_powered_bondable,
3226         .send_opcode = MGMT_OP_PAIR_DEVICE,
3227         .send_func = pair_device_send_param_func,
3228         .expect_status = MGMT_STATUS_AUTH_FAILED,
3229         .expect_func = pair_device_expect_param_func,
3230         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3231         .expect_alt_ev_len = 8,
3232         .expect_hci_command = BT_HCI_CMD_PIN_CODE_REQUEST_NEG_REPLY,
3233         .expect_hci_func = client_bdaddr_param_func,
3234         .expect_pin = true,
3235         .client_pin = pair_device_pin,
3236         .client_pin_len = sizeof(pair_device_pin),
3237 };
3238
3239 static const struct generic_data pair_device_reject_test_2 = {
3240         .setup_settings = settings_powered_bondable,
3241         .send_opcode = MGMT_OP_PAIR_DEVICE,
3242         .send_func = pair_device_send_param_func,
3243         .expect_status = MGMT_STATUS_AUTH_FAILED,
3244         .expect_func = pair_device_expect_param_func,
3245         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3246         .expect_alt_ev_len = 8,
3247         .expect_hci_command = BT_HCI_CMD_AUTH_REQUESTED,
3248         .expect_hci_param = auth_req_param,
3249         .expect_hci_len = sizeof(auth_req_param),
3250         .pin = pair_device_pin,
3251         .pin_len = sizeof(pair_device_pin),
3252 };
3253
3254 static const struct generic_data pair_device_reject_test_3 = {
3255         .setup_settings = settings_powered_bondable_linksec,
3256         .send_opcode = MGMT_OP_PAIR_DEVICE,
3257         .send_func = pair_device_send_param_func,
3258         .expect_status = MGMT_STATUS_AUTH_FAILED,
3259         .expect_func = pair_device_expect_param_func,
3260         .expect_hci_command = BT_HCI_CMD_PIN_CODE_REQUEST_NEG_REPLY,
3261         .expect_hci_func = client_bdaddr_param_func,
3262         .expect_pin = true,
3263         .client_pin = pair_device_pin,
3264         .client_pin_len = sizeof(pair_device_pin),
3265 };
3266
3267 static const struct generic_data pair_device_reject_test_4 = {
3268         .setup_settings = settings_powered_bondable_linksec,
3269         .send_opcode = MGMT_OP_PAIR_DEVICE,
3270         .send_func = pair_device_send_param_func,
3271         .expect_status = MGMT_STATUS_AUTH_FAILED,
3272         .expect_func = pair_device_expect_param_func,
3273         .pin = pair_device_pin,
3274         .pin_len = sizeof(pair_device_pin),
3275 };
3276
3277 static uint16_t settings_powered_bondable_ssp[] = {     MGMT_OP_SET_BONDABLE,
3278                                                         MGMT_OP_SET_SSP,
3279                                                         MGMT_OP_SET_POWERED,
3280                                                         0 };
3281
3282 static const struct generic_data pair_device_ssp_test_1 = {
3283         .setup_settings = settings_powered_bondable_ssp,
3284         .client_enable_ssp = true,
3285         .send_opcode = MGMT_OP_PAIR_DEVICE,
3286         .send_func = pair_device_send_param_func,
3287         .expect_status = MGMT_STATUS_SUCCESS,
3288         .expect_func = pair_device_expect_param_func,
3289         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3290         .expect_alt_ev_len = 26,
3291         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3292         .expect_hci_func = client_bdaddr_param_func,
3293         .io_cap = 0x03, /* NoInputNoOutput */
3294         .client_io_cap = 0x03, /* NoInputNoOutput */
3295 };
3296
3297 static const void *client_io_cap_param_func(uint8_t *len)
3298 {
3299         struct test_data *data = tester_get_data();
3300         const struct generic_data *test = data->test_data;
3301         static uint8_t param[9];
3302
3303         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3304         memcpy(&param[6], test->expect_hci_param, 3);
3305
3306         *len = sizeof(param);
3307
3308         return param;
3309 }
3310
3311 const uint8_t no_bonding_io_cap[] = { 0x03, 0x00, 0x00 };
3312 static const struct generic_data pair_device_ssp_test_2 = {
3313         .setup_settings = settings_powered_ssp,
3314         .client_enable_ssp = true,
3315         .send_opcode = MGMT_OP_PAIR_DEVICE,
3316         .send_func = pair_device_send_param_func,
3317         .expect_status = MGMT_STATUS_SUCCESS,
3318         .expect_func = pair_device_expect_param_func,
3319         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3320         .expect_alt_ev_len = 26,
3321         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
3322         .expect_hci_func = client_io_cap_param_func,
3323         .expect_hci_param = no_bonding_io_cap,
3324         .expect_hci_len = sizeof(no_bonding_io_cap),
3325         .io_cap = 0x03, /* NoInputNoOutput */
3326         .client_io_cap = 0x03, /* NoInputNoOutput */
3327 };
3328
3329 const uint8_t bonding_io_cap[] = { 0x03, 0x00, 0x02 };
3330 static const struct generic_data pair_device_ssp_test_3 = {
3331         .setup_settings = settings_powered_bondable_ssp,
3332         .client_enable_ssp = true,
3333         .send_opcode = MGMT_OP_PAIR_DEVICE,
3334         .send_func = pair_device_send_param_func,
3335         .expect_status = MGMT_STATUS_SUCCESS,
3336         .expect_func = pair_device_expect_param_func,
3337         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3338         .expect_alt_ev_len = 26,
3339         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
3340         .expect_hci_func = client_io_cap_param_func,
3341         .expect_hci_param = bonding_io_cap,
3342         .expect_hci_len = sizeof(bonding_io_cap),
3343         .io_cap = 0x03, /* NoInputNoOutput */
3344         .client_io_cap = 0x03, /* NoInputNoOutput */
3345 };
3346
3347 static const struct generic_data pair_device_ssp_test_4 = {
3348         .setup_settings = settings_powered_bondable_ssp,
3349         .client_enable_ssp = true,
3350         .send_opcode = MGMT_OP_PAIR_DEVICE,
3351         .send_func = pair_device_send_param_func,
3352         .expect_status = MGMT_STATUS_SUCCESS,
3353         .expect_func = pair_device_expect_param_func,
3354         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3355         .expect_alt_ev_len = 26,
3356         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3357         .expect_hci_func = client_bdaddr_param_func,
3358         .io_cap = 0x01, /* DisplayYesNo */
3359         .client_io_cap = 0x01, /* DisplayYesNo */
3360 };
3361
3362 const uint8_t mitm_no_bonding_io_cap[] = { 0x01, 0x00, 0x01 };
3363 static const struct generic_data pair_device_ssp_test_5 = {
3364         .setup_settings = settings_powered_ssp,
3365         .client_enable_ssp = true,
3366         .send_opcode = MGMT_OP_PAIR_DEVICE,
3367         .send_func = pair_device_send_param_func,
3368         .expect_status = MGMT_STATUS_SUCCESS,
3369         .expect_func = pair_device_expect_param_func,
3370         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3371         .expect_alt_ev_len = 26,
3372         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
3373         .expect_hci_func = client_io_cap_param_func,
3374         .expect_hci_param = mitm_no_bonding_io_cap,
3375         .expect_hci_len = sizeof(mitm_no_bonding_io_cap),
3376         .io_cap = 0x01, /* DisplayYesNo */
3377         .client_io_cap = 0x01, /* DisplayYesNo */
3378 };
3379
3380 const uint8_t mitm_bonding_io_cap[] = { 0x01, 0x00, 0x03 };
3381 static const struct generic_data pair_device_ssp_test_6 = {
3382         .setup_settings = settings_powered_bondable_ssp,
3383         .client_enable_ssp = true,
3384         .send_opcode = MGMT_OP_PAIR_DEVICE,
3385         .send_func = pair_device_send_param_func,
3386         .expect_status = MGMT_STATUS_SUCCESS,
3387         .expect_func = pair_device_expect_param_func,
3388         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3389         .expect_alt_ev_len = 26,
3390         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
3391         .expect_hci_func = client_io_cap_param_func,
3392         .expect_hci_param = mitm_bonding_io_cap,
3393         .expect_hci_len = sizeof(mitm_bonding_io_cap),
3394         .io_cap = 0x01, /* DisplayYesNo */
3395         .client_io_cap = 0x01, /* DisplayYesNo */
3396 };
3397
3398 static const struct generic_data pair_device_ssp_reject_1 = {
3399         .setup_settings = settings_powered_bondable_ssp,
3400         .client_enable_ssp = true,
3401         .send_opcode = MGMT_OP_PAIR_DEVICE,
3402         .send_func = pair_device_send_param_func,
3403         .expect_status = MGMT_STATUS_AUTH_FAILED,
3404         .expect_func = pair_device_expect_param_func,
3405         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3406         .expect_alt_ev_len = 8,
3407         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_NEG_REPLY,
3408         .expect_hci_func = client_bdaddr_param_func,
3409         .io_cap = 0x01, /* DisplayYesNo */
3410         .client_io_cap = 0x01, /* DisplayYesNo */
3411         .client_auth_req = 0x01, /* No Bonding - MITM */
3412         .reject_confirm = true,
3413 };
3414
3415 static const struct generic_data pair_device_ssp_reject_2 = {
3416         .setup_settings = settings_powered_bondable_ssp,
3417         .client_enable_ssp = true,
3418         .send_opcode = MGMT_OP_PAIR_DEVICE,
3419         .send_func = pair_device_send_param_func,
3420         .expect_status = MGMT_STATUS_AUTH_FAILED,
3421         .expect_func = pair_device_expect_param_func,
3422         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3423         .expect_alt_ev_len = 8,
3424         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3425         .expect_hci_func = client_bdaddr_param_func,
3426         .io_cap = 0x01, /* DisplayYesNo */
3427         .client_io_cap = 0x01, /* DisplayYesNo */
3428         .client_reject_confirm = true,
3429 };
3430
3431 static const struct generic_data pair_device_ssp_nonbondable_1 = {
3432         .setup_settings = settings_powered_ssp,
3433         .client_enable_ssp = true,
3434         .send_opcode = MGMT_OP_PAIR_DEVICE,
3435         .send_func = pair_device_send_param_func,
3436         .expect_status = MGMT_STATUS_SUCCESS,
3437         .expect_func = pair_device_expect_param_func,
3438         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3439         .expect_alt_ev_len = 26,
3440         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3441         .expect_hci_func = client_bdaddr_param_func,
3442         .io_cap = 0x01, /* DisplayYesNo */
3443         .client_io_cap = 0x01, /* DisplayYesNo */
3444 };
3445
3446 static const struct generic_data pair_device_le_success_test_1 = {
3447         .setup_settings = settings_powered_bondable,
3448         .send_opcode = MGMT_OP_PAIR_DEVICE,
3449         .send_func = pair_device_send_param_func,
3450         .just_works = true,
3451         .expect_status = MGMT_STATUS_SUCCESS,
3452         .expect_func = pair_device_expect_param_func,
3453         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3454         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3455 };
3456
3457 static bool ltk_is_authenticated(const struct mgmt_ltk_info *ltk)
3458 {
3459         switch (ltk->type) {
3460         case 0x01:
3461         case 0x03:
3462                 return true;
3463         default:
3464                 return false;
3465         }
3466 }
3467
3468 static bool ltk_is_sc(const struct mgmt_ltk_info *ltk)
3469 {
3470         switch (ltk->type) {
3471         case 0x02:
3472         case 0x03:
3473         case 0x04:
3474                 return true;
3475         default:
3476                 return false;
3477         }
3478 }
3479
3480 static bool verify_ltk(const void *param, uint16_t length)
3481 {
3482         struct test_data *data = tester_get_data();
3483         const struct generic_data *test = data->test_data;
3484         const struct mgmt_ev_new_long_term_key *ev = param;
3485
3486         if (length != sizeof(struct mgmt_ev_new_long_term_key)) {
3487                 tester_warn("Invalid new ltk length %u != %zu", length,
3488                                 sizeof(struct mgmt_ev_new_long_term_key));
3489                 return false;
3490         }
3491
3492         if (test->just_works && ltk_is_authenticated(&ev->key)) {
3493                 tester_warn("Authenticated key for just-works");
3494                 return false;
3495         }
3496
3497         if (!test->just_works && !ltk_is_authenticated(&ev->key)) {
3498                 tester_warn("Unauthenticated key for MITM");
3499                 return false;
3500         }
3501
3502         if (test->expect_sc_key && !ltk_is_sc(&ev->key)) {
3503                 tester_warn("Non-LE SC key for SC pairing");
3504                 return false;
3505         }
3506
3507         if (!test->expect_sc_key && ltk_is_sc(&ev->key)) {
3508                 tester_warn("SC key for Non-SC pairing");
3509                 return false;
3510         }
3511
3512         return true;
3513 }
3514
3515 static const struct generic_data pair_device_le_success_test_2 = {
3516         .setup_settings = settings_powered_bondable,
3517         .io_cap = 0x02, /* KeyboardOnly */
3518         .client_io_cap = 0x04, /* KeyboardDisplay */
3519         .send_opcode = MGMT_OP_PAIR_DEVICE,
3520         .send_func = pair_device_send_param_func,
3521         .expect_status = MGMT_STATUS_SUCCESS,
3522         .expect_func = pair_device_expect_param_func,
3523         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3524         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3525         .verify_alt_ev_func = verify_ltk,
3526 };
3527
3528 static uint16_t settings_powered_sc_bondable_le_ssp[] = {
3529                                                 MGMT_OP_SET_BONDABLE,
3530                                                 MGMT_OP_SET_LE,
3531                                                 MGMT_OP_SET_SSP,
3532                                                 MGMT_OP_SET_SECURE_CONN,
3533                                                 MGMT_OP_SET_POWERED,
3534                                                 0 };
3535
3536 static const struct generic_data pair_device_smp_bredr_test_1 = {
3537         .setup_settings = settings_powered_sc_bondable_le_ssp,
3538         .client_enable_ssp = true,
3539         .client_enable_le = true,
3540         .client_enable_sc = true,
3541         .expect_sc_key = true,
3542         .just_works = true,
3543         .send_opcode = MGMT_OP_PAIR_DEVICE,
3544         .send_func = pair_device_send_param_func,
3545         .expect_status = MGMT_STATUS_SUCCESS,
3546         .expect_func = pair_device_expect_param_func,
3547         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3548         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3549         .verify_alt_ev_func = verify_ltk,
3550         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3551         .expect_hci_func = client_bdaddr_param_func,
3552         .io_cap = 0x03, /* NoInputNoOutput */
3553         .client_io_cap = 0x03, /* NoInputNoOutput */
3554 };
3555
3556 static const struct generic_data pair_device_smp_bredr_test_2 = {
3557         .setup_settings = settings_powered_sc_bondable_le_ssp,
3558         .client_enable_ssp = true,
3559         .client_enable_le = true,
3560         .client_enable_sc = true,
3561         .expect_sc_key = true,
3562         .send_opcode = MGMT_OP_PAIR_DEVICE,
3563         .send_func = pair_device_send_param_func,
3564         .expect_status = MGMT_STATUS_SUCCESS,
3565         .expect_func = pair_device_expect_param_func,
3566         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3567         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3568         .verify_alt_ev_func = verify_ltk,
3569         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3570         .expect_hci_func = client_bdaddr_param_func,
3571         .io_cap = 0x01, /* DisplayYesNo */
3572         .client_io_cap = 0x01, /* DisplayYesNo */
3573 };
3574
3575 static const struct generic_data pair_device_le_reject_test_1 = {
3576         .setup_settings = settings_powered_bondable,
3577         .io_cap = 0x02, /* KeyboardOnly */
3578         .client_io_cap = 0x04, /* KeyboardDisplay */
3579         .send_opcode = MGMT_OP_PAIR_DEVICE,
3580         .send_func = pair_device_send_param_func,
3581         .expect_status = MGMT_STATUS_AUTH_FAILED,
3582         .expect_func = pair_device_expect_param_func,
3583         .expect_alt_ev =  MGMT_EV_AUTH_FAILED,
3584         .expect_alt_ev_len = sizeof(struct mgmt_ev_auth_failed),
3585         .reject_confirm = true,
3586 };
3587
3588 static uint16_t settings_powered_sc_bondable[] = { MGMT_OP_SET_BONDABLE,
3589                                                 MGMT_OP_SET_SECURE_CONN,
3590                                                 MGMT_OP_SET_POWERED, 0 };
3591
3592 static const struct generic_data pair_device_le_sc_legacy_test_1 = {
3593         .setup_settings = settings_powered_sc_bondable,
3594         .send_opcode = MGMT_OP_PAIR_DEVICE,
3595         .send_func = pair_device_send_param_func,
3596         .just_works = true,
3597         .expect_status = MGMT_STATUS_SUCCESS,
3598         .expect_func = pair_device_expect_param_func,
3599         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3600         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3601         .verify_alt_ev_func = verify_ltk,
3602 };
3603
3604 static const struct generic_data pair_device_le_sc_success_test_1 = {
3605         .setup_settings = settings_powered_sc_bondable,
3606         .send_opcode = MGMT_OP_PAIR_DEVICE,
3607         .send_func = pair_device_send_param_func,
3608         .just_works = true,
3609         .client_enable_sc = true,
3610         .expect_sc_key = true,
3611         .expect_status = MGMT_STATUS_SUCCESS,
3612         .expect_func = pair_device_expect_param_func,
3613         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3614         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3615         .verify_alt_ev_func = verify_ltk,
3616 };
3617
3618 static const struct generic_data pair_device_le_sc_success_test_2 = {
3619         .setup_settings = settings_powered_sc_bondable,
3620         .send_opcode = MGMT_OP_PAIR_DEVICE,
3621         .send_func = pair_device_send_param_func,
3622         .client_enable_sc = true,
3623         .expect_sc_key = true,
3624         .io_cap = 0x02, /* KeyboardOnly */
3625         .client_io_cap = 0x02, /* KeyboardOnly */
3626         .expect_status = MGMT_STATUS_SUCCESS,
3627         .expect_func = pair_device_expect_param_func,
3628         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3629         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3630         .verify_alt_ev_func = verify_ltk,
3631 };
3632
3633 static bool lk_is_authenticated(const struct mgmt_link_key_info *lk)
3634 {
3635         switch (lk->type) {
3636         case 0x00: /* Combination Key */
3637         case 0x01: /* Local Unit Key */
3638         case 0x02: /* Remote Unit Key */
3639         case 0x03: /* Debug Combination Key */
3640                 if (lk->pin_len == 16)
3641                         return true;
3642                 return false;
3643         case 0x05: /* Authenticated Combination Key generated from P-192 */
3644         case 0x08: /* Authenticated Combination Key generated from P-256 */
3645                 return true;
3646         default:
3647                 return false;
3648         }
3649 }
3650
3651 static bool lk_is_sc(const struct mgmt_link_key_info *lk)
3652 {
3653         switch (lk->type) {
3654         case 0x07: /* Unauthenticated Combination Key generated from P-256 */
3655         case 0x08: /* Authenticated Combination Key generated from P-256 */
3656                 return true;
3657         default:
3658                 return false;
3659         }
3660 }
3661
3662 static bool verify_link_key(const void *param, uint16_t length)
3663 {
3664         struct test_data *data = tester_get_data();
3665         const struct generic_data *test = data->test_data;
3666         const struct mgmt_ev_new_link_key *ev = param;
3667
3668         if (length != sizeof(struct mgmt_ev_new_link_key)) {
3669                 tester_warn("Invalid new Link Key length %u != %zu", length,
3670                                 sizeof(struct mgmt_ev_new_link_key));
3671                 return false;
3672         }
3673
3674         if (test->just_works && lk_is_authenticated(&ev->key)) {
3675                 tester_warn("Authenticated key for just-works");
3676                 return false;
3677         }
3678
3679         if (!test->just_works && !lk_is_authenticated(&ev->key)) {
3680                 tester_warn("Unauthenticated key for MITM");
3681                 return false;
3682         }
3683
3684         if (test->expect_sc_key && !lk_is_sc(&ev->key)) {
3685                 tester_warn("Non-LE SC key for SC pairing");
3686                 return false;
3687         }
3688
3689         if (!test->expect_sc_key && lk_is_sc(&ev->key)) {
3690                 tester_warn("SC key for Non-SC pairing");
3691                 return false;
3692         }
3693
3694         return true;
3695 }
3696
3697 static uint16_t settings_powered_le_sc_bondable[] = {
3698                                                 MGMT_OP_SET_LE,
3699                                                 MGMT_OP_SET_SSP,
3700                                                 MGMT_OP_SET_BONDABLE,
3701                                                 MGMT_OP_SET_SECURE_CONN,
3702                                                 MGMT_OP_SET_POWERED, 0 };
3703
3704 static const struct generic_data pair_device_le_sc_success_test_3 = {
3705         .setup_settings = settings_powered_le_sc_bondable,
3706         .send_opcode = MGMT_OP_PAIR_DEVICE,
3707         .send_func = pair_device_send_param_func,
3708         .addr_type_avail = true,
3709         .addr_type = 0x01,
3710         .client_enable_sc = true,
3711         .client_enable_ssp = true,
3712         .client_enable_adv = true,
3713         .expect_sc_key = true,
3714         .io_cap = 0x02, /* KeyboardOnly */
3715         .client_io_cap = 0x02, /* KeyboardOnly */
3716         .expect_status = MGMT_STATUS_SUCCESS,
3717         .expect_func = pair_device_expect_param_func,
3718         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3719         .expect_alt_ev_len = 26,
3720         .verify_alt_ev_func = verify_link_key,
3721 };
3722
3723 static uint16_t settings_powered_connectable_bondable[] = {
3724                                                 MGMT_OP_SET_BONDABLE,
3725                                                 MGMT_OP_SET_CONNECTABLE,
3726                                                 MGMT_OP_SET_POWERED, 0 };
3727
3728 static const struct generic_data pairing_acceptor_legacy_1 = {
3729         .setup_settings = settings_powered_connectable_bondable,
3730         .pin = pair_device_pin,
3731         .pin_len = sizeof(pair_device_pin),
3732         .client_pin = pair_device_pin,
3733         .client_pin_len = sizeof(pair_device_pin),
3734         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3735         .expect_alt_ev_len = 26,
3736 };
3737
3738 static const struct generic_data pairing_acceptor_legacy_2 = {
3739         .setup_settings = settings_powered_connectable_bondable,
3740         .expect_pin = true,
3741         .client_pin = pair_device_pin,
3742         .client_pin_len = sizeof(pair_device_pin),
3743         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3744         .expect_alt_ev_len = 8,
3745 };
3746
3747 static const struct generic_data pairing_acceptor_legacy_3 = {
3748         .setup_settings = settings_powered_connectable,
3749         .client_pin = pair_device_pin,
3750         .client_pin_len = sizeof(pair_device_pin),
3751         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3752         .expect_alt_ev_len = 8,
3753         .expect_hci_command = BT_HCI_CMD_PIN_CODE_REQUEST_NEG_REPLY,
3754         .expect_hci_func = client_bdaddr_param_func,
3755 };
3756
3757 static uint16_t settings_powered_connectable_bondable_linksec[] = {
3758                                                 MGMT_OP_SET_BONDABLE,
3759                                                 MGMT_OP_SET_CONNECTABLE,
3760                                                 MGMT_OP_SET_LINK_SECURITY,
3761                                                 MGMT_OP_SET_POWERED, 0 };
3762
3763 static const struct generic_data pairing_acceptor_linksec_1 = {
3764         .setup_settings = settings_powered_connectable_bondable_linksec,
3765         .pin = pair_device_pin,
3766         .pin_len = sizeof(pair_device_pin),
3767         .client_pin = pair_device_pin,
3768         .client_pin_len = sizeof(pair_device_pin),
3769         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3770         .expect_alt_ev_len = 26,
3771 };
3772
3773 static const struct generic_data pairing_acceptor_linksec_2 = {
3774         .setup_settings = settings_powered_connectable_bondable_linksec,
3775         .expect_pin = true,
3776         .client_pin = pair_device_pin,
3777         .client_pin_len = sizeof(pair_device_pin),
3778         .expect_alt_ev = MGMT_EV_CONNECT_FAILED,
3779         .expect_alt_ev_len = 8,
3780 };
3781
3782 static uint16_t settings_powered_connectable_bondable_ssp[] = {
3783                                                 MGMT_OP_SET_BONDABLE,
3784                                                 MGMT_OP_SET_CONNECTABLE,
3785                                                 MGMT_OP_SET_SSP,
3786                                                 MGMT_OP_SET_POWERED, 0 };
3787
3788 static const struct generic_data pairing_acceptor_ssp_1 = {
3789         .setup_settings = settings_powered_connectable_bondable_ssp,
3790         .client_enable_ssp = true,
3791         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3792         .expect_alt_ev_len = 26,
3793         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3794         .expect_hci_func = client_bdaddr_param_func,
3795         .io_cap = 0x03, /* NoInputNoOutput */
3796         .client_io_cap = 0x03, /* NoInputNoOutput */
3797         .just_works = true,
3798 };
3799
3800 static const struct generic_data pairing_acceptor_ssp_2 = {
3801         .setup_settings = settings_powered_connectable_bondable_ssp,
3802         .client_enable_ssp = true,
3803         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3804         .expect_alt_ev_len = 26,
3805         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3806         .expect_hci_func = client_bdaddr_param_func,
3807         .io_cap = 0x01, /* DisplayYesNo */
3808         .client_io_cap = 0x01, /* DisplayYesNo */
3809 };
3810
3811 static const struct generic_data pairing_acceptor_ssp_3 = {
3812         .setup_settings = settings_powered_connectable_bondable_ssp,
3813         .client_enable_ssp = true,
3814         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3815         .expect_alt_ev_len = 26,
3816         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3817         .expect_hci_func = client_bdaddr_param_func,
3818         .io_cap = 0x01, /* DisplayYesNo */
3819         .client_io_cap = 0x01, /* DisplayYesNo */
3820         .just_works = true,
3821 };
3822
3823 static const void *client_io_cap_reject_param_func(uint8_t *len)
3824 {
3825         struct test_data *data = tester_get_data();
3826         static uint8_t param[7];
3827
3828         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3829         param[6] = 0x18; /* Pairing Not Allowed */
3830
3831         *len = sizeof(param);
3832
3833         return param;
3834 }
3835
3836 static uint16_t settings_powered_connectable_ssp[] = {
3837                                                 MGMT_OP_SET_CONNECTABLE,
3838                                                 MGMT_OP_SET_SSP,
3839                                                 MGMT_OP_SET_POWERED, 0 };
3840
3841 static const struct generic_data pairing_acceptor_ssp_4 = {
3842         .setup_settings = settings_powered_connectable_ssp,
3843         .client_enable_ssp = true,
3844         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3845         .expect_alt_ev_len = 8,
3846         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_NEG_REPLY,
3847         .expect_hci_func = client_io_cap_reject_param_func,
3848         .io_cap = 0x01, /* DisplayYesNo */
3849         .client_io_cap = 0x01, /* DisplayYesNo */
3850         .client_auth_req = 0x02, /* Dedicated Bonding - No MITM */
3851 };
3852
3853 static uint16_t settings_powered_sc_bondable_connectable_le_ssp[] = {
3854                                                 MGMT_OP_SET_BONDABLE,
3855                                                 MGMT_OP_SET_CONNECTABLE,
3856                                                 MGMT_OP_SET_LE,
3857                                                 MGMT_OP_SET_SSP,
3858                                                 MGMT_OP_SET_SECURE_CONN,
3859                                                 MGMT_OP_SET_POWERED,
3860                                                 0 };
3861
3862 static const struct generic_data pairing_acceptor_smp_bredr_1 = {
3863         .setup_settings = settings_powered_sc_bondable_connectable_le_ssp,
3864         .client_enable_ssp = true,
3865         .client_enable_le = true,
3866         .client_enable_sc = true,
3867         .expect_sc_key = true,
3868         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3869         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3870         .verify_alt_ev_func = verify_ltk,
3871         .just_works = true,
3872         .io_cap = 0x03, /* NoInputNoOutput */
3873         .client_io_cap = 0x03, /* No InputNoOutput */
3874         .client_auth_req = 0x00, /* No Bonding - No MITM */
3875 };
3876
3877 static const struct generic_data pairing_acceptor_smp_bredr_2 = {
3878         .setup_settings = settings_powered_sc_bondable_connectable_le_ssp,
3879         .client_enable_ssp = true,
3880         .client_enable_le = true,
3881         .client_enable_sc = true,
3882         .expect_sc_key = true,
3883         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3884         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3885         .verify_alt_ev_func = verify_ltk,
3886         .io_cap = 0x01, /* DisplayYesNo */
3887         .client_io_cap = 0x01, /* DisplayYesNo */
3888         .client_auth_req = 0x02, /* Dedicated Bonding - No MITM */
3889 };
3890
3891 static uint16_t settings_powered_bondable_connectable_advertising[] = {
3892                                         MGMT_OP_SET_BONDABLE,
3893                                         MGMT_OP_SET_CONNECTABLE,
3894                                         MGMT_OP_SET_ADVERTISING,
3895                                         MGMT_OP_SET_POWERED, 0 };
3896
3897 static const struct generic_data pairing_acceptor_le_1 = {
3898         .setup_settings = settings_powered_bondable_connectable_advertising,
3899         .io_cap = 0x03, /* NoInputNoOutput */
3900         .client_io_cap = 0x03, /* NoInputNoOutput */
3901         .just_works = true,
3902         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3903         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3904         .verify_alt_ev_func = verify_ltk,
3905 };
3906
3907 static const struct generic_data pairing_acceptor_le_2 = {
3908         .setup_settings = settings_powered_bondable_connectable_advertising,
3909         .io_cap = 0x04, /* KeyboardDisplay */
3910         .client_io_cap = 0x04, /* KeyboardDisplay */
3911         .client_auth_req = 0x05, /* Bonding - MITM */
3912         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3913         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3914         .verify_alt_ev_func = verify_ltk,
3915 };
3916
3917 static const struct generic_data pairing_acceptor_le_3 = {
3918         .setup_settings = settings_powered_bondable_connectable_advertising,
3919         .io_cap = 0x04, /* KeyboardDisplay */
3920         .client_io_cap = 0x04, /* KeyboardDisplay */
3921         .expect_alt_ev =  MGMT_EV_AUTH_FAILED,
3922         .expect_alt_ev_len = sizeof(struct mgmt_ev_auth_failed),
3923         .reject_confirm = true,
3924 };
3925
3926 static const struct generic_data pairing_acceptor_le_4 = {
3927         .setup_settings = settings_powered_bondable_connectable_advertising,
3928         .io_cap = 0x02, /* KeyboardOnly */
3929         .client_io_cap = 0x04, /* KeyboardDisplay */
3930         .client_auth_req = 0x05, /* Bonding - MITM */
3931         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3932         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3933         .verify_alt_ev_func = verify_ltk,
3934 };
3935
3936 static const struct generic_data pairing_acceptor_le_5 = {
3937         .setup_settings = settings_powered_bondable_connectable_advertising,
3938         .io_cap = 0x02, /* KeyboardOnly */
3939         .client_io_cap = 0x04, /* KeyboardDisplay */
3940         .client_auth_req = 0x05, /* Bonding - MITM */
3941         .reject_confirm = true,
3942         .expect_alt_ev =  MGMT_EV_AUTH_FAILED,
3943         .expect_alt_ev_len = sizeof(struct mgmt_ev_auth_failed),
3944 };
3945
3946 static const char unpair_device_param[] = {
3947                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00 };
3948 static const char unpair_device_rsp[] = {
3949                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
3950 static const char unpair_device_invalid_param_1[] = {
3951                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff, 0x00 };
3952 static const char unpair_device_invalid_param_rsp_1[] = {
3953                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3954 static const char unpair_device_invalid_param_2[] = {
3955                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x02 };
3956 static const char unpair_device_invalid_param_rsp_2[] = {
3957                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
3958
3959 static const struct generic_data unpair_device_not_powered_test_1 = {
3960         .send_opcode = MGMT_OP_UNPAIR_DEVICE,
3961         .send_param = unpair_device_param,
3962         .send_len = sizeof(unpair_device_param),
3963         .expect_status = MGMT_STATUS_NOT_POWERED,
3964         .expect_param = unpair_device_rsp,
3965         .expect_len = sizeof(unpair_device_rsp),
3966 };
3967
3968 static const struct generic_data unpair_device_invalid_param_test_1 = {
3969         .send_opcode = MGMT_OP_UNPAIR_DEVICE,
3970         .send_param = unpair_device_invalid_param_1,
3971         .send_len = sizeof(unpair_device_invalid_param_1),
3972         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3973         .expect_param = unpair_device_invalid_param_rsp_1,
3974         .expect_len = sizeof(unpair_device_invalid_param_rsp_1),
3975 };
3976
3977 static const struct generic_data unpair_device_invalid_param_test_2 = {
3978         .send_opcode = MGMT_OP_UNPAIR_DEVICE,
3979         .send_param = unpair_device_invalid_param_2,
3980         .send_len = sizeof(unpair_device_invalid_param_2),
3981         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3982         .expect_param = unpair_device_invalid_param_rsp_2,
3983         .expect_len = sizeof(unpair_device_invalid_param_rsp_2),
3984 };
3985
3986 static const char disconnect_invalid_param_1[] = {
3987                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3988 static const char disconnect_invalid_param_rsp_1[] = {
3989                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3990
3991 static const struct generic_data disconnect_invalid_param_test_1 = {
3992         .send_opcode = MGMT_OP_DISCONNECT,
3993         .send_param = disconnect_invalid_param_1,
3994         .send_len = sizeof(disconnect_invalid_param_1),
3995         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3996         .expect_param = disconnect_invalid_param_rsp_1,
3997         .expect_len = sizeof(disconnect_invalid_param_rsp_1),
3998 };
3999
4000 static const char block_device_invalid_param_1[] = {
4001                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
4002 static const char block_device_invalid_param_rsp_1[] = {
4003                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
4004
4005 static const struct generic_data block_device_invalid_param_test_1 = {
4006         .send_opcode = MGMT_OP_BLOCK_DEVICE,
4007         .send_param = block_device_invalid_param_1,
4008         .send_len = sizeof(block_device_invalid_param_1),
4009         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4010         .expect_param = block_device_invalid_param_rsp_1,
4011         .expect_len = sizeof(block_device_invalid_param_rsp_1),
4012 };
4013
4014 static const char unblock_device_invalid_param_1[] = {
4015                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
4016 static const char unblock_device_invalid_param_rsp_1[] = {
4017                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
4018
4019 static const struct generic_data unblock_device_invalid_param_test_1 = {
4020         .send_opcode = MGMT_OP_UNBLOCK_DEVICE,
4021         .send_param = unblock_device_invalid_param_1,
4022         .send_len = sizeof(unblock_device_invalid_param_1),
4023         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4024         .expect_param = unblock_device_invalid_param_rsp_1,
4025         .expect_len = sizeof(unblock_device_invalid_param_rsp_1),
4026 };
4027
4028 static const char set_static_addr_valid_param[] = {
4029                         0x11, 0x22, 0x33, 0x44, 0x55, 0xc0 };
4030 static const char set_static_addr_settings[] = { 0x00, 0x82, 0x00, 0x00 };
4031
4032 static const struct generic_data set_static_addr_success_test = {
4033         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
4034         .send_param = set_static_addr_valid_param,
4035         .send_len = sizeof(set_static_addr_valid_param),
4036         .expect_status = MGMT_STATUS_SUCCESS,
4037         .expect_param = set_static_addr_settings,
4038         .expect_len = sizeof(set_static_addr_settings),
4039         .expect_settings_set = MGMT_SETTING_STATIC_ADDRESS,
4040 };
4041
4042 static const char set_static_addr_settings_dual[] = { 0x80, 0x00, 0x00, 0x00 };
4043
4044 static const struct generic_data set_static_addr_success_test_2 = {
4045         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
4046         .send_param = set_static_addr_valid_param,
4047         .send_len = sizeof(set_static_addr_valid_param),
4048         .expect_status = MGMT_STATUS_SUCCESS,
4049         .expect_param = set_static_addr_settings_dual,
4050         .expect_len = sizeof(set_static_addr_settings_dual),
4051 };
4052
4053 static const struct generic_data set_static_addr_failure_test = {
4054         .setup_settings = settings_powered,
4055         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
4056         .send_param = set_static_addr_valid_param,
4057         .send_len = sizeof(set_static_addr_valid_param),
4058         .expect_status = MGMT_STATUS_REJECTED,
4059 };
4060
4061 static const struct generic_data set_static_addr_failure_test_2 = {
4062         .setup_settings = settings_powered,
4063         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
4064         .send_param = set_static_addr_valid_param,
4065         .send_len = sizeof(set_static_addr_valid_param),
4066         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
4067 };
4068
4069 static const char set_scan_params_valid_param[] = { 0x60, 0x00, 0x30, 0x00 };
4070
4071 static const struct generic_data set_scan_params_success_test = {
4072         .send_opcode = MGMT_OP_SET_SCAN_PARAMS,
4073         .send_param = set_scan_params_valid_param,
4074         .send_len = sizeof(set_scan_params_valid_param),
4075         .expect_status = MGMT_STATUS_SUCCESS,
4076 };
4077
4078 static const char load_irks_empty_list[] = { 0x00, 0x00 };
4079
4080 static const struct generic_data load_irks_success1_test = {
4081         .send_opcode = MGMT_OP_LOAD_IRKS,
4082         .send_param = load_irks_empty_list,
4083         .send_len = sizeof(load_irks_empty_list),
4084         .expect_status = MGMT_STATUS_SUCCESS,
4085 };
4086
4087 static const char load_irks_one_irk[] = { 0x01, 0x00,
4088                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x01,
4089                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
4090                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
4091
4092 static const struct generic_data load_irks_success2_test = {
4093         .send_opcode = MGMT_OP_LOAD_IRKS,
4094         .send_param = load_irks_one_irk,
4095         .send_len = sizeof(load_irks_one_irk),
4096         .expect_status = MGMT_STATUS_SUCCESS,
4097 };
4098
4099 static const char load_irks_nval_addr_type[] = { 0x01, 0x00,
4100                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00,
4101                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
4102                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
4103
4104 static const struct generic_data load_irks_nval_param1_test = {
4105         .send_opcode = MGMT_OP_LOAD_IRKS,
4106         .send_param = load_irks_nval_addr_type,
4107         .send_len = sizeof(load_irks_nval_addr_type),
4108         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4109 };
4110
4111 static const char load_irks_nval_rand_addr[] = { 0x01, 0x00,
4112                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x02,
4113                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
4114                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
4115
4116 static const struct generic_data load_irks_nval_param2_test = {
4117         .send_opcode = MGMT_OP_LOAD_IRKS,
4118         .send_param = load_irks_nval_rand_addr,
4119         .send_len = sizeof(load_irks_nval_rand_addr),
4120         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4121 };
4122
4123 static const char load_irks_nval_len[] = { 0x02, 0x00, 0xff, 0xff };
4124
4125 static const struct generic_data load_irks_nval_param3_test = {
4126         .send_opcode = MGMT_OP_LOAD_IRKS,
4127         .send_param = load_irks_nval_len,
4128         .send_len = sizeof(load_irks_nval_len),
4129         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4130 };
4131
4132 static const struct generic_data load_irks_not_supported_test = {
4133         .send_opcode = MGMT_OP_LOAD_IRKS,
4134         .send_param = load_irks_empty_list,
4135         .send_len = sizeof(load_irks_empty_list),
4136         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
4137 };
4138
4139 static const char set_privacy_1_valid_param[] = { 0x01,
4140                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
4141                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
4142 static const char set_privacy_settings_param[] = { 0x80, 0x20, 0x00, 0x00 };
4143
4144 static const struct generic_data set_privacy_success_1_test = {
4145         .send_opcode = MGMT_OP_SET_PRIVACY,
4146         .send_param = set_privacy_1_valid_param,
4147         .send_len = sizeof(set_privacy_1_valid_param),
4148         .expect_status = MGMT_STATUS_SUCCESS,
4149         .expect_param = set_privacy_settings_param,
4150         .expect_len = sizeof(set_privacy_settings_param),
4151         .expect_settings_set = MGMT_SETTING_PRIVACY,
4152 };
4153
4154 static const char set_privacy_2_valid_param[] = { 0x02,
4155                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
4156                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
4157
4158 static const struct generic_data set_privacy_success_2_test = {
4159         .send_opcode = MGMT_OP_SET_PRIVACY,
4160         .send_param = set_privacy_2_valid_param,
4161         .send_len = sizeof(set_privacy_2_valid_param),
4162         .expect_status = MGMT_STATUS_SUCCESS,
4163         .expect_param = set_privacy_settings_param,
4164         .expect_len = sizeof(set_privacy_settings_param),
4165         .expect_settings_set = MGMT_SETTING_PRIVACY,
4166 };
4167
4168 static const struct generic_data set_privacy_powered_test = {
4169         .setup_settings = settings_powered,
4170         .send_opcode = MGMT_OP_SET_PRIVACY,
4171         .send_param = set_privacy_1_valid_param,
4172         .send_len = sizeof(set_privacy_1_valid_param),
4173         .expect_status = MGMT_STATUS_REJECTED,
4174 };
4175
4176 static const char set_privacy_nval_param[] = { 0xff,
4177                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
4178                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
4179 static const struct generic_data set_privacy_nval_param_test = {
4180         .send_opcode = MGMT_OP_SET_PRIVACY,
4181         .send_param = set_privacy_nval_param,
4182         .send_len = sizeof(set_privacy_nval_param),
4183         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4184 };
4185
4186 static const void *get_clock_info_send_param_func(uint16_t *len)
4187 {
4188         struct test_data *data = tester_get_data();
4189         static uint8_t param[7];
4190
4191         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4192         param[6] = 0x00; /* Address type */
4193
4194         *len = sizeof(param);
4195
4196         return param;
4197 }
4198
4199 static const void *get_clock_info_expect_param_func(uint16_t *len)
4200 {
4201         struct test_data *data = tester_get_data();
4202         static uint8_t param[17];
4203         struct mgmt_rp_get_clock_info *rp;
4204
4205         rp = (struct mgmt_rp_get_clock_info *)param;
4206         memset(param, 0, sizeof(param));
4207         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4208         param[6] = 0x00; /* Address type */
4209
4210         rp->local_clock = 0x11223344;
4211         rp->piconet_clock = 0x11223344;
4212         rp->accuracy = 0x5566;
4213
4214         *len = sizeof(param);
4215
4216         return param;
4217 }
4218
4219 static const void *get_clock_info_expect_param_not_powered_func(uint16_t *len)
4220 {
4221         struct test_data *data = tester_get_data();
4222         static uint8_t param[17];
4223
4224         memset(param, 0, sizeof(param));
4225         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4226         param[6] = 0x00; /* Address type */
4227
4228         *len = sizeof(param);
4229
4230         return param;
4231 }
4232
4233 static const void *get_conn_info_send_param_func(uint16_t *len)
4234 {
4235         struct test_data *data = tester_get_data();
4236         static uint8_t param[7];
4237
4238         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4239         param[6] = 0x00; /* Address type */
4240
4241         *len = sizeof(param);
4242
4243         return param;
4244 }
4245
4246 static const void *get_conn_info_expect_param_func(uint16_t *len)
4247 {
4248         struct test_data *data = tester_get_data();
4249         static uint8_t param[10];
4250
4251         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4252         param[6] = 0x00; /* Address type */
4253         param[7] = 0xff; /* RSSI (= -1) */
4254         param[8] = 0xff; /* TX power (= -1) */
4255         param[9] = 0x04; /* max TX power */
4256
4257         *len = sizeof(param);
4258
4259         return param;
4260 }
4261
4262 static const void *get_conn_info_error_expect_param_func(uint16_t *len)
4263 {
4264         struct test_data *data = tester_get_data();
4265         static uint8_t param[10];
4266
4267         /* All unset parameters shall be 0 in case of error */
4268         memset(param, 0, sizeof(param));
4269
4270         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4271         param[6] = 0x00; /* Address type */
4272
4273         *len = sizeof(param);
4274
4275         return param;
4276 }
4277
4278 static const struct generic_data get_clock_info_succes1_test = {
4279         .setup_settings = settings_powered_connectable_bondable_ssp,
4280         .send_opcode = MGMT_OP_GET_CLOCK_INFO,
4281         .send_func = get_clock_info_send_param_func,
4282         .expect_status = MGMT_STATUS_SUCCESS,
4283         .expect_func = get_clock_info_expect_param_func,
4284 };
4285
4286 static const struct generic_data get_clock_info_fail1_test = {
4287         .send_opcode = MGMT_OP_GET_CLOCK_INFO,
4288         .send_func = get_clock_info_send_param_func,
4289         .expect_status = MGMT_STATUS_NOT_POWERED,
4290         .expect_func = get_clock_info_expect_param_not_powered_func,
4291 };
4292
4293 static const struct generic_data get_conn_info_succes1_test = {
4294         .setup_settings = settings_powered_connectable_bondable_ssp,
4295         .send_opcode = MGMT_OP_GET_CONN_INFO,
4296         .send_func = get_conn_info_send_param_func,
4297         .expect_status = MGMT_STATUS_SUCCESS,
4298         .expect_func = get_conn_info_expect_param_func,
4299 };
4300
4301 static const struct generic_data get_conn_info_ncon_test = {
4302         .setup_settings = settings_powered_connectable_bondable_ssp,
4303         .send_opcode = MGMT_OP_GET_CONN_INFO,
4304         .send_func = get_conn_info_send_param_func,
4305         .expect_status = MGMT_STATUS_NOT_CONNECTED,
4306         .expect_func = get_conn_info_error_expect_param_func,
4307 };
4308
4309 static const void *get_conn_info_expect_param_power_off_func(uint16_t *len)
4310 {
4311         struct test_data *data = tester_get_data();
4312         static uint8_t param[10];
4313
4314         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
4315         param[6] = 0x00; /* Address type */
4316         param[7] = 127; /* RSSI */
4317         param[8] = 127; /* TX power */
4318         param[9] = 127; /* max TX power */
4319
4320         *len = sizeof(param);
4321
4322         return param;
4323 }
4324
4325 static const struct generic_data get_conn_info_power_off_test = {
4326         .setup_settings = settings_powered_connectable_bondable_ssp,
4327         .send_opcode = MGMT_OP_GET_CONN_INFO,
4328         .send_func = get_conn_info_send_param_func,
4329         .force_power_off = true,
4330         .expect_status = MGMT_STATUS_NOT_POWERED,
4331         .expect_func = get_conn_info_expect_param_power_off_func,
4332         .fail_tolerant = true,
4333 };
4334
4335 static const uint8_t load_conn_param_nval_1[16] = { 0x12, 0x11 };
4336 static const struct generic_data load_conn_params_fail_1 = {
4337         .send_opcode = MGMT_OP_LOAD_CONN_PARAM,
4338         .send_param = load_conn_param_nval_1,
4339         .send_len = sizeof(load_conn_param_nval_1),
4340         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4341 };
4342
4343 static const uint8_t add_device_nval_1[] = {
4344                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4345                                         0x00,
4346                                         0x00,
4347 };
4348 static const uint8_t add_device_rsp[] =  {
4349                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4350                                         0x00,
4351 };
4352 static const struct generic_data add_device_fail_1 = {
4353         .send_opcode = MGMT_OP_ADD_DEVICE,
4354         .send_param = add_device_nval_1,
4355         .send_len = sizeof(add_device_nval_1),
4356         .expect_param = add_device_rsp,
4357         .expect_len = sizeof(add_device_rsp),
4358         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4359 };
4360
4361 static const uint8_t add_device_nval_2[] = {
4362                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4363                                         0x00,
4364                                         0x02,
4365 };
4366 static const struct generic_data add_device_fail_2 = {
4367         .send_opcode = MGMT_OP_ADD_DEVICE,
4368         .send_param = add_device_nval_2,
4369         .send_len = sizeof(add_device_nval_2),
4370         .expect_param = add_device_rsp,
4371         .expect_len = sizeof(add_device_rsp),
4372         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4373 };
4374
4375 static const uint8_t add_device_nval_3[] = {
4376                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4377                                         0x00,
4378                                         0xff,
4379 };
4380 static const struct generic_data add_device_fail_3 = {
4381         .send_opcode = MGMT_OP_ADD_DEVICE,
4382         .send_param = add_device_nval_3,
4383         .send_len = sizeof(add_device_nval_3),
4384         .expect_param = add_device_rsp,
4385         .expect_len = sizeof(add_device_rsp),
4386         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4387 };
4388
4389 static const uint8_t add_device_nval_4[] = {
4390                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4391                                         0x02,
4392                                         0x02,
4393 };
4394 static const uint8_t add_device_rsp_4[] =  {
4395                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4396                                         0x02,
4397 };
4398 static const struct generic_data add_device_fail_4 = {
4399         .send_opcode = MGMT_OP_ADD_DEVICE,
4400         .send_param = add_device_nval_4,
4401         .send_len = sizeof(add_device_nval_4),
4402         .expect_param = add_device_rsp_4,
4403         .expect_len = sizeof(add_device_rsp_4),
4404         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4405 };
4406
4407 static const uint8_t add_device_success_param_1[] = {
4408                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4409                                         0x00,
4410                                         0x01,
4411 };
4412 static const struct generic_data add_device_success_1 = {
4413         .send_opcode = MGMT_OP_ADD_DEVICE,
4414         .send_param = add_device_success_param_1,
4415         .send_len = sizeof(add_device_success_param_1),
4416         .expect_param = add_device_rsp,
4417         .expect_len = sizeof(add_device_rsp),
4418         .expect_status = MGMT_STATUS_SUCCESS,
4419         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
4420         .expect_alt_ev_param = add_device_success_param_1,
4421         .expect_alt_ev_len = sizeof(add_device_success_param_1),
4422 };
4423
4424 static const uint8_t add_device_success_param_2[] = {
4425                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4426                                         0x01,
4427                                         0x00,
4428 };
4429 static const uint8_t add_device_rsp_le[] =  {
4430                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4431                                         0x01,
4432 };
4433 static const struct generic_data add_device_success_2 = {
4434         .send_opcode = MGMT_OP_ADD_DEVICE,
4435         .send_param = add_device_success_param_2,
4436         .send_len = sizeof(add_device_success_param_2),
4437         .expect_param = add_device_rsp_le,
4438         .expect_len = sizeof(add_device_rsp_le),
4439         .expect_status = MGMT_STATUS_SUCCESS,
4440         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
4441         .expect_alt_ev_param = add_device_success_param_2,
4442         .expect_alt_ev_len = sizeof(add_device_success_param_2),
4443 };
4444
4445 static const uint8_t add_device_success_param_3[] = {
4446                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4447                                         0x01,
4448                                         0x02,
4449 };
4450 static const struct generic_data add_device_success_3 = {
4451         .send_opcode = MGMT_OP_ADD_DEVICE,
4452         .send_param = add_device_success_param_3,
4453         .send_len = sizeof(add_device_success_param_3),
4454         .expect_param = add_device_rsp_le,
4455         .expect_len = sizeof(add_device_rsp_le),
4456         .expect_status = MGMT_STATUS_SUCCESS,
4457         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
4458         .expect_alt_ev_param = add_device_success_param_3,
4459         .expect_alt_ev_len = sizeof(add_device_success_param_3),
4460 };
4461
4462 static const struct generic_data add_device_success_4 = {
4463         .setup_settings = settings_powered,
4464         .send_opcode = MGMT_OP_ADD_DEVICE,
4465         .send_param = add_device_success_param_1,
4466         .send_len = sizeof(add_device_success_param_1),
4467         .expect_param = add_device_rsp,
4468         .expect_len = sizeof(add_device_rsp),
4469         .expect_status = MGMT_STATUS_SUCCESS,
4470         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
4471         .expect_alt_ev_param = add_device_success_param_1,
4472         .expect_alt_ev_len = sizeof(add_device_success_param_1),
4473         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
4474         .expect_hci_param = set_connectable_scan_enable_param,
4475         .expect_hci_len = sizeof(set_connectable_scan_enable_param),
4476 };
4477
4478 static const uint8_t le_scan_enable[] = { 0x01, 0x01 };
4479 static const struct generic_data add_device_success_5 = {
4480         .setup_settings = settings_powered_le,
4481         .send_opcode = MGMT_OP_ADD_DEVICE,
4482         .send_param = add_device_success_param_2,
4483         .send_len = sizeof(add_device_success_param_2),
4484         .expect_param = add_device_rsp_le,
4485         .expect_len = sizeof(add_device_rsp_le),
4486         .expect_status = MGMT_STATUS_SUCCESS,
4487         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
4488         .expect_alt_ev_param = add_device_success_param_2,
4489         .expect_alt_ev_len = sizeof(add_device_success_param_2),
4490         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
4491         .expect_hci_param = le_scan_enable,
4492         .expect_hci_len = sizeof(le_scan_enable),
4493 };
4494
4495 static const uint8_t remove_device_nval_1[] = {
4496                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4497                                         0xff,
4498 };
4499 static const struct generic_data remove_device_fail_1 = {
4500         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4501         .send_param = remove_device_nval_1,
4502         .send_len = sizeof(remove_device_nval_1),
4503         .expect_param = remove_device_nval_1,
4504         .expect_len = sizeof(remove_device_nval_1),
4505         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4506 };
4507
4508 static const uint8_t remove_device_param_1[] = {
4509                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4510                                         0x00,
4511 };
4512 static const struct generic_data remove_device_fail_2 = {
4513         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4514         .send_param = remove_device_param_1,
4515         .send_len = sizeof(remove_device_param_1),
4516         .expect_param = remove_device_param_1,
4517         .expect_len = sizeof(remove_device_param_1),
4518         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4519 };
4520
4521 static const uint8_t remove_device_param_3[] = {
4522                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4523                                         0x02,
4524 };
4525 static const struct generic_data remove_device_fail_3 = {
4526         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4527         .send_param = remove_device_param_3,
4528         .send_len = sizeof(remove_device_param_3),
4529         .expect_param = remove_device_param_3,
4530         .expect_len = sizeof(remove_device_param_3),
4531         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4532 };
4533
4534 static const struct generic_data remove_device_success_1 = {
4535         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4536         .send_param = remove_device_param_1,
4537         .send_len = sizeof(remove_device_param_1),
4538         .expect_param = remove_device_param_1,
4539         .expect_len = sizeof(remove_device_param_1),
4540         .expect_status = MGMT_STATUS_SUCCESS,
4541         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
4542         .expect_alt_ev_param = remove_device_param_1,
4543         .expect_alt_ev_len = sizeof(remove_device_param_1),
4544 };
4545
4546 static const struct generic_data remove_device_success_2 = {
4547         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4548         .send_param = remove_device_param_1,
4549         .send_len = sizeof(remove_device_param_1),
4550         .expect_param = remove_device_param_1,
4551         .expect_len = sizeof(remove_device_param_1),
4552         .expect_status = MGMT_STATUS_SUCCESS,
4553         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
4554         .expect_alt_ev_param = remove_device_param_1,
4555         .expect_alt_ev_len = sizeof(remove_device_param_1),
4556         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
4557         .expect_hci_param = set_connectable_off_scan_enable_param,
4558         .expect_hci_len = sizeof(set_connectable_off_scan_enable_param),
4559 };
4560
4561 static const struct generic_data remove_device_success_3 = {
4562         .setup_settings = settings_powered,
4563         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4564         .send_param = remove_device_param_1,
4565         .send_len = sizeof(remove_device_param_1),
4566         .expect_param = remove_device_param_1,
4567         .expect_len = sizeof(remove_device_param_1),
4568         .expect_status = MGMT_STATUS_SUCCESS,
4569         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
4570         .expect_alt_ev_param = remove_device_param_1,
4571         .expect_alt_ev_len = sizeof(remove_device_param_1),
4572 };
4573
4574 static const uint8_t remove_device_param_2[] =  {
4575                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
4576                                         0x01,
4577 };
4578 static const struct generic_data remove_device_success_4 = {
4579         .setup_settings = settings_powered,
4580         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4581         .send_param = remove_device_param_2,
4582         .send_len = sizeof(remove_device_param_2),
4583         .expect_param = remove_device_param_2,
4584         .expect_len = sizeof(remove_device_param_2),
4585         .expect_status = MGMT_STATUS_SUCCESS,
4586         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
4587         .expect_alt_ev_param = remove_device_param_2,
4588         .expect_alt_ev_len = sizeof(remove_device_param_2),
4589 };
4590
4591 static const struct generic_data remove_device_success_5 = {
4592         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4593         .send_param = remove_device_param_2,
4594         .send_len = sizeof(remove_device_param_2),
4595         .expect_param = remove_device_param_2,
4596         .expect_len = sizeof(remove_device_param_2),
4597         .expect_status = MGMT_STATUS_SUCCESS,
4598         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
4599         .expect_alt_ev_param = remove_device_param_2,
4600         .expect_alt_ev_len = sizeof(remove_device_param_2),
4601 };
4602
4603 static const uint8_t remove_device_param_all[7] =  { 0x00 };
4604
4605 static const struct generic_data remove_device_success_6 = {
4606         .send_opcode = MGMT_OP_REMOVE_DEVICE,
4607         .send_param = remove_device_param_all,
4608         .send_len = sizeof(remove_device_param_all),
4609         .expect_param = remove_device_param_all,
4610         .expect_len = sizeof(remove_device_param_all),
4611         .expect_status = MGMT_STATUS_SUCCESS,
4612 };
4613
4614 static const struct generic_data read_adv_features_invalid_param_test = {
4615         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
4616         .send_param = dummy_data,
4617         .send_len = sizeof(dummy_data),
4618         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4619 };
4620
4621 static const struct generic_data read_adv_features_invalid_index_test = {
4622         .send_index_none = true,
4623         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
4624         .expect_status = MGMT_STATUS_INVALID_INDEX,
4625 };
4626
4627 static const uint8_t read_adv_features_rsp_1[] =  {
4628         0x7f, 0xf0, 0x01, 0x00, /* supported flags */
4629         0x1f,                   /* max_adv_data_len */
4630         0x1f,                   /* max_scan_rsp_len */
4631         0x05,                   /* max_instances */
4632         0x00,                   /* num_instances */
4633 };
4634
4635 static const struct generic_data read_adv_features_success_1 = {
4636         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
4637         .expect_param = read_adv_features_rsp_1,
4638         .expect_len = sizeof(read_adv_features_rsp_1),
4639         .expect_status = MGMT_STATUS_SUCCESS,
4640 };
4641
4642 static const uint8_t read_adv_features_rsp_2[] =  {
4643         0x7f, 0xf0, 0x01, 0x00, /* supported flags */
4644         0x1f,                   /* max_adv_data_len */
4645         0x1f,                   /* max_scan_rsp_len */
4646         0x05,                   /* max_instances */
4647         0x01,                   /* num_instances */
4648         0x01,                   /* instance identifiers */
4649 };
4650
4651 static const struct generic_data read_adv_features_success_2 = {
4652         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
4653         .expect_param = read_adv_features_rsp_2,
4654         .expect_len = sizeof(read_adv_features_rsp_2),
4655         .expect_status = MGMT_STATUS_SUCCESS,
4656 };
4657
4658 /* simple add advertising command */
4659 static const uint8_t add_advertising_param_uuid[] = {
4660         0x01,                   /* adv instance */
4661         0x00, 0x00, 0x00, 0x00, /* flags: none */
4662         0x00, 0x00,             /* duration: default */
4663         0x00, 0x00,             /* timeout: none */
4664         0x09,                   /* adv data len */
4665         0x00,                   /* scan rsp len */
4666         /* adv data: */
4667         0x03,                   /* AD len */
4668         0x02,                   /* AD type: some 16 bit service class UUIDs */
4669         0x0d, 0x18,             /* heart rate monitor */
4670         0x04,                   /* AD len */
4671         0xff,                   /* AD type: manufacturer specific data */
4672         0x01, 0x02, 0x03,       /* custom advertising data */
4673 };
4674
4675 /* add advertising with scan response data */
4676 static const uint8_t add_advertising_param_scanrsp[] = {
4677         /* instance, flags, duration, timeout, adv data len: same as before */
4678         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4679         0x0a,                   /* scan rsp len */
4680         /* adv data: same as before */
4681         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4682         /* scan rsp data: */
4683         0x03,                   /* AD len */
4684         0x19,                   /* AD type: external appearance */
4685         0x40, 0x03,             /* some custom appearance */
4686         0x05,                   /* AD len */
4687         0x03,                   /* AD type: all 16 bit service class UUIDs */
4688         0x0d, 0x18,             /* heart rate monitor */
4689         0x0f, 0x18,             /* battery service */
4690 };
4691
4692 /* add advertising with timeout */
4693 static const uint8_t add_advertising_param_timeout[] = {
4694         /* instance, flags, duration: same as before */
4695         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4696         0x05, 0x00,             /* timeout: 5 seconds */
4697         /* adv data: same as before */
4698         0x09, 0x00, 0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4699 };
4700
4701 /* add advertising with connectable flag */
4702 static const uint8_t add_advertising_param_connectable[] = {
4703         0x01,                   /* adv instance */
4704         0x01, 0x00, 0x00, 0x00, /* flags: connectable*/
4705         /* duration, timeout, adv/scan data: same as before */
4706         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4707         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4708 };
4709
4710 /* add advertising with general discoverable flag */
4711 static const uint8_t add_advertising_param_general_discov[] = {
4712         0x01,                   /* adv instance */
4713         0x02, 0x00, 0x00, 0x00, /* flags: general discoverable*/
4714         /* duration, timeout, adv/scan data: same as before */
4715         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4716         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4717 };
4718
4719 /* add advertising with limited discoverable flag */
4720 static const uint8_t add_advertising_param_limited_discov[] = {
4721         0x01,                   /* adv instance */
4722         0x04, 0x00, 0x00, 0x00, /* flags: limited discoverable */
4723         /* duration, timeout, adv/scan data: same as before */
4724         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4725         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4726 };
4727
4728 /* add advertising with managed flags */
4729 static const uint8_t add_advertising_param_managed[] = {
4730         0x01,                   /* adv instance */
4731         0x08, 0x00, 0x00, 0x00, /* flags: managed flags */
4732         /* duration, timeout, adv/scan data: same as before */
4733         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4734         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4735 };
4736
4737 /* add advertising with tx power flag */
4738 static const uint8_t add_advertising_param_txpwr[] = {
4739         0x01,                   /* adv instance */
4740         0x10, 0x00, 0x00, 0x00, /* flags: tx power */
4741         /* duration, timeout, adv/scan data: same as before */
4742         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4743         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4744 };
4745
4746 /* add advertising command for a second instance */
4747 static const uint8_t add_advertising_param_test2[] = {
4748         0x02,                           /* adv instance */
4749         0x00, 0x00, 0x00, 0x00,         /* flags: none */
4750         0x00, 0x00,                     /* duration: default */
4751         0x01, 0x00,                     /* timeout: 1 second */
4752         0x07,                           /* adv data len */
4753         0x00,                           /* scan rsp len */
4754         /* adv data: */
4755         0x06,                           /* AD len */
4756         0x08,                           /* AD type: shortened local name */
4757         0x74, 0x65, 0x73, 0x74, 0x32,   /* "test2" */
4758 };
4759
4760 static const uint8_t advertising_instance1_param[] = {
4761         0x01,
4762 };
4763
4764 static const uint8_t advertising_instance2_param[] = {
4765         0x02,
4766 };
4767
4768 static const uint8_t set_adv_data_uuid[] = {
4769         /* adv data len */
4770         0x09,
4771         /* advertise heart rate monitor and manufacturer specific data */
4772         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4773         /* padding */
4774         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4775         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4776         0x00, 0x00,
4777 };
4778
4779 static const uint8_t set_adv_data_test1[] = {
4780         0x07,                           /* adv data len */
4781         0x06,                           /* AD len */
4782         0x08,                           /* AD type: shortened local name */
4783         0x74, 0x65, 0x73, 0x74, 0x31,   /* "test1" */
4784         /* padding */
4785         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4786         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4787         0x00, 0x00, 0x00, 0x00,
4788 };
4789
4790 static const uint8_t set_adv_data_test2[] = {
4791         0x07,                           /* adv data len */
4792         0x06,                           /* AD len */
4793         0x08,                           /* AD type: shortened local name */
4794         0x74, 0x65, 0x73, 0x74, 0x32,   /* "test2" */
4795         /* padding */
4796         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4797         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4798         0x00, 0x00, 0x00, 0x00,
4799 };
4800
4801 static const uint8_t set_adv_data_txpwr[] = {
4802         0x03,                   /* adv data len */
4803         0x02,                   /* AD len */
4804         0x0a,                   /* AD type: tx power */
4805         0x00,                   /* tx power */
4806         /* padding */
4807         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4808         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4809         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4810 };
4811
4812 static const uint8_t set_adv_data_general_discov[] = {
4813         0x0c,                   /* adv data len */
4814         0x02,                   /* AD len */
4815         0x01,                   /* AD type: flags */
4816         0x02,                   /* general discoverable */
4817         0x03,                   /* AD len */
4818         0x02,                   /* AD type: some 16bit service class UUIDs */
4819         0x0d, 0x18,             /* heart rate monitor */
4820         0x04,                   /* AD len */
4821         0xff,                   /* AD type: manufacturer specific data */
4822         0x01, 0x02, 0x03,       /* custom advertising data */
4823         /* padding */
4824         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4825         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4826 };
4827
4828 static const uint8_t set_adv_data_limited_discov[] = {
4829         0x0c,                   /* adv data len */
4830         0x02,                   /* AD len */
4831         0x01,                   /* AD type: flags */
4832         0x01,                   /* limited discoverable */
4833         /* rest: same as before */
4834         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4835         /* padding */
4836         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4837         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4838 };
4839
4840 static const uint8_t set_adv_data_uuid_txpwr[] = {
4841         0x0c,                   /* adv data len */
4842         0x03,                   /* AD len */
4843         0x02,                   /* AD type: some 16bit service class UUIDs */
4844         0x0d, 0x18,             /* heart rate monitor */
4845         0x04,                   /* AD len */
4846         0xff,                   /* AD type: manufacturer specific data */
4847         0x01, 0x02, 0x03,       /* custom advertising data */
4848         0x02,                   /* AD len */
4849         0x0a,                   /* AD type: tx power */
4850         0x00,                   /* tx power */
4851         /* padding */
4852         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4853         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4854 };
4855
4856 static const uint8_t set_scan_rsp_uuid[] = {
4857         0x0a,                   /* scan rsp data len */
4858         0x03,                   /* AD len */
4859         0x19,                   /* AD type: external appearance */
4860         0x40, 0x03,             /* some custom appearance */
4861         0x05,                   /* AD len */
4862         0x03,                   /* AD type: all 16 bit service class UUIDs */
4863         0x0d, 0x18, 0x0f, 0x18, /* heart rate monitor, battery service */
4864         /* padding */
4865         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4866         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4867         0x00,
4868 };
4869
4870 static const uint8_t add_advertising_invalid_param_1[] = {
4871         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
4872         0x03, 0x03, 0x0d, 0x18,
4873         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4874         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4875         0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
4876 };
4877
4878 static const uint8_t add_advertising_invalid_param_2[] = {
4879         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4880         0x04, 0x03, 0x0d, 0x18,
4881         0x04, 0xff, 0x01, 0x02, 0x03,
4882 };
4883
4884 static const uint8_t add_advertising_invalid_param_3[] = {
4885         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4886         0x03, 0x03, 0x0d, 0x18,
4887         0x02, 0xff, 0x01, 0x02, 0x03,
4888 };
4889
4890 static const uint8_t add_advertising_invalid_param_4[] = {
4891         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4892         0x03, 0x03, 0x0d, 0x18,
4893         0x05, 0xff, 0x01, 0x02, 0x03,
4894 };
4895
4896 static const uint8_t add_advertising_invalid_param_5[] = {
4897         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1D, 0x00,
4898         0x03, 0x03, 0x0d, 0x18,
4899         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4900         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4901         0x15, 0x16, 0x17, 0x18,
4902 };
4903
4904 static const uint8_t add_advertising_invalid_param_6[] = {
4905         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
4906         0x03, 0x03, 0x0d, 0x18,
4907         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4908         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4909         0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
4910 };
4911
4912 static const uint8_t add_advertising_invalid_param_7[] = {
4913         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4914         0x04, 0x03, 0x0d, 0x18,
4915         0x04, 0xff, 0x01, 0x02, 0x03,
4916 };
4917
4918 static const uint8_t add_advertising_invalid_param_8[] = {
4919         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4920         0x03, 0x03, 0x0d, 0x18,
4921         0x02, 0xff, 0x01, 0x02, 0x03,
4922 };
4923
4924 static const uint8_t add_advertising_invalid_param_9[] = {
4925         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4926         0x03, 0x03, 0x0d, 0x18,
4927         0x05, 0xff, 0x01, 0x02, 0x03,
4928 };
4929
4930 static const uint8_t add_advertising_invalid_param_10[] = {
4931         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1D,
4932         0x03, 0x03, 0x0d, 0x18,
4933         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4934         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4935         0x15, 0x16, 0x17, 0x18,
4936 };
4937
4938 static const struct generic_data add_advertising_fail_1 = {
4939         .setup_settings = settings_powered,
4940         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4941         .send_param = add_advertising_param_uuid,
4942         .send_len = sizeof(add_advertising_param_uuid),
4943         .expect_status = MGMT_STATUS_REJECTED,
4944 };
4945
4946 static const struct generic_data add_advertising_fail_2 = {
4947         .setup_settings = settings_powered_le,
4948         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4949         .send_param = add_advertising_invalid_param_1,
4950         .send_len = sizeof(add_advertising_invalid_param_1),
4951         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4952 };
4953
4954 static const struct generic_data add_advertising_fail_3 = {
4955         .setup_settings = settings_powered_le,
4956         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4957         .send_param = add_advertising_invalid_param_2,
4958         .send_len = sizeof(add_advertising_invalid_param_2),
4959         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4960 };
4961
4962 static const struct generic_data add_advertising_fail_4 = {
4963         .setup_settings = settings_powered_le,
4964         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4965         .send_param = add_advertising_invalid_param_3,
4966         .send_len = sizeof(add_advertising_invalid_param_3),
4967         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4968 };
4969
4970 static const struct generic_data add_advertising_fail_5 = {
4971         .setup_settings = settings_powered_le,
4972         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4973         .send_param = add_advertising_invalid_param_4,
4974         .send_len = sizeof(add_advertising_invalid_param_4),
4975         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4976 };
4977
4978 static const struct generic_data add_advertising_fail_6 = {
4979         .setup_settings = settings_powered_le,
4980         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4981         .send_param = add_advertising_invalid_param_5,
4982         .send_len = sizeof(add_advertising_invalid_param_5),
4983         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4984 };
4985
4986 static const struct generic_data add_advertising_fail_7 = {
4987         .setup_settings = settings_powered_le,
4988         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4989         .send_param = add_advertising_invalid_param_6,
4990         .send_len = sizeof(add_advertising_invalid_param_6),
4991         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4992 };
4993
4994 static const struct generic_data add_advertising_fail_8 = {
4995         .setup_settings = settings_powered_le,
4996         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4997         .send_param = add_advertising_invalid_param_7,
4998         .send_len = sizeof(add_advertising_invalid_param_7),
4999         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5000 };
5001
5002 static const struct generic_data add_advertising_fail_9 = {
5003         .setup_settings = settings_powered_le,
5004         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5005         .send_param = add_advertising_invalid_param_8,
5006         .send_len = sizeof(add_advertising_invalid_param_8),
5007         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5008 };
5009
5010 static const struct generic_data add_advertising_fail_10 = {
5011         .setup_settings = settings_powered_le,
5012         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5013         .send_param = add_advertising_invalid_param_9,
5014         .send_len = sizeof(add_advertising_invalid_param_9),
5015         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5016 };
5017
5018 static const struct generic_data add_advertising_fail_11 = {
5019         .setup_settings = settings_powered_le,
5020         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5021         .send_param = add_advertising_invalid_param_10,
5022         .send_len = sizeof(add_advertising_invalid_param_10),
5023         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5024 };
5025
5026 static const struct generic_data add_advertising_fail_12 = {
5027         .setup_settings = settings_le,
5028         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5029         .send_param = add_advertising_param_timeout,
5030         .send_len = sizeof(add_advertising_param_timeout),
5031         .expect_status = MGMT_STATUS_REJECTED,
5032 };
5033
5034 static const struct generic_data add_advertising_success_1 = {
5035         .setup_settings = settings_powered_le,
5036         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5037         .send_param = add_advertising_param_uuid,
5038         .send_len = sizeof(add_advertising_param_uuid),
5039         .expect_param = advertising_instance1_param,
5040         .expect_len = sizeof(advertising_instance1_param),
5041         .expect_status = MGMT_STATUS_SUCCESS,
5042         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
5043         .expect_alt_ev_param = advertising_instance1_param,
5044         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5045         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5046         .expect_hci_param = set_adv_data_uuid,
5047         .expect_hci_len = sizeof(set_adv_data_uuid),
5048 };
5049
5050 static const char set_powered_adv_instance_settings_param[] = {
5051         0x81, 0x02, 0x00, 0x00,
5052 };
5053
5054 static const struct generic_data add_advertising_success_pwron_data = {
5055         .send_opcode = MGMT_OP_SET_POWERED,
5056         .send_param = set_powered_on_param,
5057         .send_len = sizeof(set_powered_on_param),
5058         .expect_status = MGMT_STATUS_SUCCESS,
5059         .expect_param = set_powered_adv_instance_settings_param,
5060         .expect_len = sizeof(set_powered_adv_instance_settings_param),
5061         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5062         .expect_hci_param = set_adv_data_test1,
5063         .expect_hci_len = sizeof(set_adv_data_test1),
5064 };
5065
5066 static const struct generic_data add_advertising_success_pwron_enabled = {
5067         .send_opcode = MGMT_OP_SET_POWERED,
5068         .send_param = set_powered_on_param,
5069         .send_len = sizeof(set_powered_on_param),
5070         .expect_status = MGMT_STATUS_SUCCESS,
5071         .expect_param = set_powered_adv_instance_settings_param,
5072         .expect_len = sizeof(set_powered_adv_instance_settings_param),
5073         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
5074         .expect_hci_param = set_adv_on_set_adv_enable_param,
5075         .expect_hci_len = sizeof(set_adv_on_set_adv_enable_param),
5076 };
5077
5078 static const struct generic_data add_advertising_success_4 = {
5079         .send_opcode = MGMT_OP_SET_ADVERTISING,
5080         .send_param = set_adv_on_param,
5081         .send_len = sizeof(set_adv_on_param),
5082         .expect_status = MGMT_STATUS_SUCCESS,
5083         .expect_param = set_adv_settings_param_2,
5084         .expect_len = sizeof(set_adv_settings_param_2),
5085         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5086         .expect_hci_param = set_adv_data_txpwr,
5087         .expect_hci_len = sizeof(set_adv_data_txpwr),
5088 };
5089
5090 static const struct generic_data add_advertising_success_5 = {
5091         .send_opcode = MGMT_OP_SET_ADVERTISING,
5092         .send_param = set_adv_off_param,
5093         .send_len = sizeof(set_adv_off_param),
5094         .expect_status = MGMT_STATUS_SUCCESS,
5095         .expect_param = set_powered_adv_instance_settings_param,
5096         .expect_len = sizeof(set_powered_adv_instance_settings_param),
5097         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5098         .expect_hci_param = set_adv_data_test1,
5099         .expect_hci_len = sizeof(set_adv_data_test1),
5100 };
5101
5102 static const struct generic_data add_advertising_success_6 = {
5103         .setup_settings = settings_powered_le,
5104         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5105         .send_param = add_advertising_param_scanrsp,
5106         .send_len = sizeof(add_advertising_param_scanrsp),
5107         .expect_param = advertising_instance1_param,
5108         .expect_len = sizeof(advertising_instance1_param),
5109         .expect_status = MGMT_STATUS_SUCCESS,
5110         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
5111         .expect_alt_ev_param = advertising_instance1_param,
5112         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5113         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5114         .expect_hci_param = set_adv_data_uuid,
5115         .expect_hci_len = sizeof(set_adv_data_uuid),
5116 };
5117
5118 static const struct generic_data add_advertising_success_7 = {
5119         .setup_settings = settings_powered_le,
5120         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5121         .send_param = add_advertising_param_scanrsp,
5122         .send_len = sizeof(add_advertising_param_scanrsp),
5123         .expect_param = advertising_instance1_param,
5124         .expect_len = sizeof(advertising_instance1_param),
5125         .expect_status = MGMT_STATUS_SUCCESS,
5126         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
5127         .expect_alt_ev_param = advertising_instance1_param,
5128         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5129         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
5130         .expect_hci_param = set_scan_rsp_uuid,
5131         .expect_hci_len = sizeof(set_scan_rsp_uuid),
5132 };
5133
5134 static const struct generic_data add_advertising_success_8 = {
5135         .setup_settings = settings_powered_le,
5136         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5137         .send_param = add_advertising_param_connectable,
5138         .send_len = sizeof(add_advertising_param_connectable),
5139         .expect_param = advertising_instance1_param,
5140         .expect_len = sizeof(advertising_instance1_param),
5141         .expect_status = MGMT_STATUS_SUCCESS,
5142         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
5143         .expect_hci_param = set_connectable_on_adv_param,
5144         .expect_hci_len = sizeof(set_connectable_on_adv_param),
5145 };
5146
5147 static const struct generic_data add_advertising_success_9 = {
5148         .setup_settings = settings_powered_le,
5149         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5150         .send_param = add_advertising_param_general_discov,
5151         .send_len = sizeof(add_advertising_param_general_discov),
5152         .expect_param = advertising_instance1_param,
5153         .expect_len = sizeof(advertising_instance1_param),
5154         .expect_status = MGMT_STATUS_SUCCESS,
5155         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5156         .expect_hci_param = set_adv_data_general_discov,
5157         .expect_hci_len = sizeof(set_adv_data_general_discov),
5158 };
5159
5160 static const struct generic_data add_advertising_success_10 = {
5161         .setup_settings = settings_powered_le,
5162         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5163         .send_param = add_advertising_param_limited_discov,
5164         .send_len = sizeof(add_advertising_param_limited_discov),
5165         .expect_param = advertising_instance1_param,
5166         .expect_len = sizeof(advertising_instance1_param),
5167         .expect_status = MGMT_STATUS_SUCCESS,
5168         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5169         .expect_hci_param = set_adv_data_limited_discov,
5170         .expect_hci_len = sizeof(set_adv_data_limited_discov),
5171 };
5172
5173 static const struct generic_data add_advertising_success_11 = {
5174         .setup_settings = settings_powered_le_discoverable,
5175         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5176         .send_param = add_advertising_param_managed,
5177         .send_len = sizeof(add_advertising_param_managed),
5178         .expect_param = advertising_instance1_param,
5179         .expect_len = sizeof(advertising_instance1_param),
5180         .expect_status = MGMT_STATUS_SUCCESS,
5181         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5182         .expect_hci_param = set_adv_data_general_discov,
5183         .expect_hci_len = sizeof(set_adv_data_general_discov),
5184 };
5185
5186 static const struct generic_data add_advertising_success_12 = {
5187         .setup_settings = settings_powered_le_discoverable,
5188         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5189         .send_param = add_advertising_param_txpwr,
5190         .send_len = sizeof(add_advertising_param_txpwr),
5191         .expect_param = advertising_instance1_param,
5192         .expect_len = sizeof(advertising_instance1_param),
5193         .expect_status = MGMT_STATUS_SUCCESS,
5194         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5195         .expect_hci_param = set_adv_data_uuid_txpwr,
5196         .expect_hci_len = sizeof(set_adv_data_uuid_txpwr),
5197 };
5198
5199 static uint16_t settings_powered_le_connectable[] = {
5200                                                 MGMT_OP_SET_POWERED,
5201                                                 MGMT_OP_SET_LE,
5202                                                 MGMT_OP_SET_CONNECTABLE, 0 };
5203
5204 static const struct generic_data add_advertising_success_13 = {
5205         .setup_settings = settings_powered_le,
5206         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5207         .send_param = add_advertising_param_scanrsp,
5208         .send_len = sizeof(add_advertising_param_scanrsp),
5209         .expect_param = advertising_instance1_param,
5210         .expect_len = sizeof(advertising_instance1_param),
5211         .expect_status = MGMT_STATUS_SUCCESS,
5212         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
5213         .expect_hci_param = set_connectable_off_scan_adv_param,
5214         .expect_hci_len = sizeof(set_connectable_off_scan_adv_param),
5215         .expect_hci_param_check_func = set_connectable_off_scan_adv_check_func
5216 };
5217
5218 static uint8_t set_connectable_off_adv_param[] = {
5219                 0x64, 0x00,                             /* min_interval */
5220                 0x96, 0x00,                             /* max_interval */
5221                 0x03,                                   /* type */
5222                 0x01,                                   /* own_addr_type */
5223                 0x00,                                   /* direct_addr_type */
5224                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* direct_addr */
5225                 0x07,                                   /* channel_map */
5226                 0x00,                                   /* filter_policy */
5227 };
5228
5229 static int set_connectable_off_adv_check_func(const void *param,
5230                                                                 uint16_t length)
5231 {
5232         const uint8_t *received = param;
5233         uint8_t *expected = set_connectable_off_adv_param;
5234
5235         /* Compare the received param with expected param, but ignore the
5236          * min_internal and max_interval since these values are turned often
5237          * in the kernel and we don't want to update the expected value every
5238          * time.
5239          */
5240         return memcmp(&received[4], &expected[4], length - 4);
5241 }
5242
5243 static const struct generic_data add_advertising_success_14 = {
5244         .setup_settings = settings_powered_le,
5245         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5246         .send_param = add_advertising_param_uuid,
5247         .send_len = sizeof(add_advertising_param_uuid),
5248         .expect_param = advertising_instance1_param,
5249         .expect_len = sizeof(advertising_instance1_param),
5250         .expect_status = MGMT_STATUS_SUCCESS,
5251         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
5252         .expect_hci_param = set_connectable_off_adv_param,
5253         .expect_hci_len = sizeof(set_connectable_off_adv_param),
5254         .expect_hci_param_check_func = set_connectable_off_adv_check_func
5255 };
5256
5257 static const struct generic_data add_advertising_success_15 = {
5258         .setup_settings = settings_powered_le_connectable,
5259         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5260         .send_param = add_advertising_param_uuid,
5261         .send_len = sizeof(add_advertising_param_uuid),
5262         .expect_param = advertising_instance1_param,
5263         .expect_len = sizeof(advertising_instance1_param),
5264         .expect_status = MGMT_STATUS_SUCCESS,
5265         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
5266         .expect_hci_param = set_connectable_on_adv_param,
5267         .expect_hci_len = sizeof(set_connectable_on_adv_param),
5268 };
5269
5270 static const char set_connectable_settings_param_3[] = {
5271                                                 0x83, 0x02, 0x00, 0x00 };
5272
5273 static const struct generic_data add_advertising_success_16 = {
5274         .send_opcode = MGMT_OP_SET_CONNECTABLE,
5275         .send_param = set_connectable_on_param,
5276         .send_len = sizeof(set_connectable_on_param),
5277         .expect_status = MGMT_STATUS_SUCCESS,
5278         .expect_param = set_connectable_settings_param_3,
5279         .expect_len = sizeof(set_connectable_settings_param_3),
5280         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
5281         .expect_hci_param = set_connectable_on_adv_param,
5282         .expect_hci_len = sizeof(set_connectable_on_adv_param),
5283 };
5284
5285 static const struct generic_data add_advertising_success_17 = {
5286         .send_opcode = MGMT_OP_SET_CONNECTABLE,
5287         .send_param = set_connectable_off_param,
5288         .send_len = sizeof(set_connectable_off_param),
5289         .expect_status = MGMT_STATUS_SUCCESS,
5290         .expect_param = set_le_settings_param_2,
5291         .expect_len = sizeof(set_le_settings_param_2),
5292         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
5293         .expect_hci_param = set_connectable_off_adv_param,
5294         .expect_hci_len = sizeof(set_connectable_off_adv_param),
5295         .expect_hci_param_check_func = set_connectable_off_adv_check_func
5296 };
5297
5298 static const char set_powered_off_le_settings_param[] = {
5299         0x80, 0x02, 0x00, 0x00
5300 };
5301
5302 static const struct generic_data add_advertising_power_off = {
5303         .send_opcode = MGMT_OP_SET_POWERED,
5304         .send_param = set_powered_off_param,
5305         .send_len = sizeof(set_powered_off_param),
5306         .expect_status = MGMT_STATUS_SUCCESS,
5307         .expect_param = set_powered_off_le_settings_param,
5308         .expect_len = sizeof(set_powered_off_le_settings_param),
5309         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
5310         .expect_alt_ev_param = advertising_instance1_param,
5311         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5312 };
5313
5314 static const char set_le_settings_param_off[] = { 0x81, 0x00, 0x00, 0x00 };
5315
5316 static const struct generic_data add_advertising_le_off = {
5317         .send_opcode = MGMT_OP_SET_LE,
5318         .send_param = set_le_off_param,
5319         .send_len = sizeof(set_le_off_param),
5320         .expect_status = MGMT_STATUS_SUCCESS,
5321         .expect_param = set_le_settings_param_off,
5322         .expect_len = sizeof(set_le_settings_param_off),
5323         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
5324         .expect_alt_ev_param = advertising_instance1_param,
5325         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5326 };
5327
5328 static const struct generic_data add_advertising_success_18 = {
5329         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5330         .send_param = add_advertising_param_uuid,
5331         .send_len = sizeof(add_advertising_param_uuid),
5332         .expect_param = advertising_instance1_param,
5333         .expect_len = sizeof(advertising_instance1_param),
5334         .expect_status = MGMT_STATUS_SUCCESS,
5335         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5336         .expect_hci_param = set_adv_data_uuid,
5337         .expect_hci_len = sizeof(set_adv_data_uuid),
5338 };
5339
5340 static const struct generic_data add_advertising_timeout_expired = {
5341         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
5342         .expect_alt_ev_param = advertising_instance1_param,
5343         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5344         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
5345         .expect_hci_param = set_adv_on_set_adv_disable_param,
5346         .expect_hci_len = sizeof(set_adv_on_set_adv_disable_param),
5347 };
5348
5349 static const uint8_t remove_advertising_param_1[] = {
5350         0x01,
5351 };
5352
5353 static const uint8_t remove_advertising_param_2[] = {
5354         0x00,
5355 };
5356
5357 static const struct generic_data remove_advertising_fail_1 = {
5358         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
5359         .send_param = remove_advertising_param_1,
5360         .send_len = sizeof(remove_advertising_param_1),
5361         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5362 };
5363
5364 static const struct generic_data remove_advertising_success_1 = {
5365         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
5366         .send_param = remove_advertising_param_1,
5367         .send_len = sizeof(remove_advertising_param_1),
5368         .expect_status = MGMT_STATUS_SUCCESS,
5369         .expect_param = remove_advertising_param_1,
5370         .expect_len = sizeof(remove_advertising_param_1),
5371         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
5372         .expect_alt_ev_param = advertising_instance1_param,
5373         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5374         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
5375         .expect_hci_param = set_adv_off_param,
5376         .expect_hci_len = sizeof(set_adv_off_param),
5377 };
5378
5379 static const struct generic_data remove_advertising_success_2 = {
5380         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
5381         .send_param = remove_advertising_param_2,
5382         .send_len = sizeof(remove_advertising_param_2),
5383         .expect_status = MGMT_STATUS_SUCCESS,
5384         .expect_param = remove_advertising_param_2,
5385         .expect_len = sizeof(remove_advertising_param_2),
5386         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
5387         .expect_alt_ev_param = advertising_instance1_param,
5388         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5389         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
5390         .expect_hci_param = set_adv_off_param,
5391         .expect_hci_len = sizeof(set_adv_off_param),
5392 };
5393
5394 static const struct generic_data multi_advertising_switch = {
5395         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
5396         .expect_alt_ev_param = advertising_instance1_param,
5397         .expect_alt_ev_len = sizeof(advertising_instance1_param),
5398         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5399         .expect_hci_param = set_adv_data_test2,
5400         .expect_hci_len = sizeof(set_adv_data_test2),
5401 };
5402
5403 static const struct generic_data multi_advertising_add_second = {
5404         .send_opcode = MGMT_OP_ADD_ADVERTISING,
5405         .send_param = add_advertising_param_test2,
5406         .send_len = sizeof(add_advertising_param_test2),
5407         .expect_param = advertising_instance2_param,
5408         .expect_len = sizeof(advertising_instance2_param),
5409         .expect_status = MGMT_STATUS_SUCCESS,
5410         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
5411         .expect_alt_ev_param = advertising_instance2_param,
5412         .expect_alt_ev_len = sizeof(advertising_instance2_param),
5413         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
5414         .expect_hci_param = set_adv_data_test2,
5415         .expect_hci_len = sizeof(set_adv_data_test2),
5416 };
5417
5418 /* based on G-Tag ADV_DATA */
5419 static const uint8_t adv_data_invalid_significant_len[] = { 0x02, 0x01, 0x06,
5420                 0x0d, 0xff, 0x80, 0x01, 0x02, 0x15, 0x12, 0x34, 0x80, 0x91,
5421                 0xd0, 0xf2, 0xbb, 0xc5, 0x03, 0x02, 0x0f, 0x18, 0x00, 0x00,
5422                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
5423
5424 static const char device_found_valid[] = { 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,
5425                 0x01, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x02, 0x01,
5426                 0x06, 0x0d, 0xff, 0x80, 0x01, 0x02, 0x15, 0x12, 0x34, 0x80,
5427                 0x91, 0xd0, 0xf2, 0xbb, 0xc5, 0x03, 0x02, 0x0f, 0x18 };
5428
5429 static const struct generic_data device_found_gtag = {
5430         .setup_settings = settings_powered_le,
5431         .send_opcode = MGMT_OP_START_DISCOVERY,
5432         .send_param = start_discovery_le_param,
5433         .send_len = sizeof(start_discovery_le_param),
5434         .expect_status = MGMT_STATUS_SUCCESS,
5435         .expect_param = start_discovery_le_param,
5436         .expect_len = sizeof(start_discovery_le_param),
5437         .expect_alt_ev = MGMT_EV_DEVICE_FOUND,
5438         .expect_alt_ev_param = device_found_valid,
5439         .expect_alt_ev_len = sizeof(device_found_valid),
5440         .set_adv = true,
5441         .adv_data_len = sizeof(adv_data_invalid_significant_len),
5442         .adv_data = adv_data_invalid_significant_len,
5443 };
5444
5445 static const uint8_t adv_data_invalid_field_len[] = { 0x02, 0x01, 0x01,
5446                 0x05, 0x09, 0x74, 0x65, 0x73, 0x74,
5447                 0xa0, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05};
5448
5449 static const char device_found_valid2[] = { 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,
5450                 0x01, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x02, 0x01,
5451                 0x01, 0x05, 0x09, 0x74, 0x65, 0x73, 0x74};
5452
5453 static const struct generic_data device_found_invalid_field = {
5454         .setup_settings = settings_powered_le,
5455         .send_opcode = MGMT_OP_START_DISCOVERY,
5456         .send_param = start_discovery_le_param,
5457         .send_len = sizeof(start_discovery_le_param),
5458         .expect_status = MGMT_STATUS_SUCCESS,
5459         .expect_param = start_discovery_le_param,
5460         .expect_len = sizeof(start_discovery_le_param),
5461         .expect_alt_ev = MGMT_EV_DEVICE_FOUND,
5462         .expect_alt_ev_param = device_found_valid2,
5463         .expect_alt_ev_len = sizeof(device_found_valid2),
5464         .set_adv = true,
5465         .adv_data_len = sizeof(adv_data_invalid_field_len),
5466         .adv_data = adv_data_invalid_field_len,
5467 };
5468
5469 static const struct generic_data read_local_oob_not_powered_test = {
5470         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
5471         .expect_status = MGMT_STATUS_NOT_POWERED,
5472 };
5473
5474 static const struct generic_data read_local_oob_invalid_param_test = {
5475         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
5476         .send_param = dummy_data,
5477         .send_len = sizeof(dummy_data),
5478         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5479 };
5480
5481 static const struct generic_data read_local_oob_invalid_index_test = {
5482         .send_index_none = true,
5483         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
5484         .expect_status = MGMT_STATUS_INVALID_INDEX,
5485 };
5486
5487 static const struct generic_data read_local_oob_legacy_pairing_test = {
5488         .setup_settings = settings_powered,
5489         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
5490         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
5491 };
5492
5493 static const struct generic_data read_local_oob_success_ssp_test = {
5494         .setup_settings = settings_powered_ssp,
5495         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
5496         .expect_status = MGMT_STATUS_SUCCESS,
5497         .expect_ignore_param = true,
5498         .expect_hci_command = BT_HCI_CMD_READ_LOCAL_OOB_DATA,
5499 };
5500
5501 static const struct generic_data read_local_oob_success_sc_test = {
5502         .setup_settings = settings_powered_sc,
5503         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
5504         .expect_status = MGMT_STATUS_SUCCESS,
5505         .expect_ignore_param = true,
5506         .expect_hci_command = BT_HCI_CMD_READ_LOCAL_OOB_EXT_DATA,
5507 };
5508
5509 static const uint8_t oob_type_bredr[] = { 0x01 };
5510 static const struct generic_data read_local_oob_ext_invalid_index_test = {
5511         .send_index_none = true,
5512         .send_opcode = MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
5513         .send_param = oob_type_bredr,
5514         .send_len = sizeof(oob_type_bredr),
5515         .expect_status = MGMT_STATUS_INVALID_INDEX,
5516 };
5517
5518 static const struct generic_data read_local_oob_ext_legacy_pairing_test = {
5519         .setup_settings = settings_powered,
5520         .send_opcode = MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
5521         .send_param = oob_type_bredr,
5522         .send_len = sizeof(oob_type_bredr),
5523         .expect_ignore_param = true,
5524         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
5525 };
5526
5527 static const struct generic_data read_local_oob_ext_success_ssp_test = {
5528         .setup_settings = settings_powered_ssp,
5529         .send_opcode = MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
5530         .send_param = oob_type_bredr,
5531         .send_len = sizeof(oob_type_bredr),
5532         .expect_status = MGMT_STATUS_SUCCESS,
5533         .expect_ignore_param = true,
5534         .expect_hci_command = BT_HCI_CMD_READ_LOCAL_OOB_DATA,
5535 };
5536
5537 static const struct generic_data read_local_oob_ext_success_sc_test = {
5538         .setup_settings = settings_powered_sc,
5539         .send_opcode = MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
5540         .send_param = oob_type_bredr,
5541         .send_len = sizeof(oob_type_bredr),
5542         .expect_status = MGMT_STATUS_SUCCESS,
5543         .expect_ignore_param = true,
5544         .expect_hci_command = BT_HCI_CMD_READ_LOCAL_OOB_EXT_DATA,
5545 };
5546
5547 static const uint8_t le_states_conn_peripheral_adv_connectable[] = {
5548                         0x00, 0x00, 0x20, 0x00, 0x40, 0x00, 0x00, 0x00};
5549 static const uint8_t le_states_conn_peripheral_adv_non_connectable[] = {
5550                         0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00};
5551 static const uint8_t le_states_conn_central_adv_connectable[] = {
5552                         0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00};
5553 static const uint8_t le_states_conn_central_adv_non_connectable[] = {
5554                         0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00};
5555
5556 static const struct generic_data conn_peripheral_adv_connectable_test = {
5557         .setup_le_states = true,
5558         .le_states = le_states_conn_peripheral_adv_connectable,
5559         .setup_settings = settings_powered_le,
5560         .client_enable_le = true
5561 };
5562
5563 static const struct generic_data conn_peripheral_adv_non_connectable_test = {
5564         .setup_le_states = true,
5565         .le_states = le_states_conn_peripheral_adv_non_connectable,
5566         .setup_settings = settings_powered_le,
5567         .client_enable_le = true
5568 };
5569
5570 static const struct generic_data conn_central_adv_connectable_test = {
5571         .setup_le_states = true,
5572         .le_states = le_states_conn_central_adv_connectable,
5573         .setup_settings = settings_powered_le,
5574         .client_enable_le = true,
5575         .client_enable_adv = 1
5576 };
5577
5578 static const struct generic_data conn_central_adv_non_connectable_test = {
5579         .setup_le_states = true,
5580         .le_states = le_states_conn_central_adv_non_connectable,
5581         .setup_settings = settings_powered_le,
5582         .client_enable_le = true,
5583         .client_enable_adv = 1
5584 };
5585
5586 static const char ext_ctrl_info1[] = {
5587         0x00, 0x00, 0x00, 0x01, 0xaa, 0x00, /* btaddr */
5588         0x09, /* version */
5589         0xf1, 0x05, /* manufacturer */
5590         0xff, 0xbf, 0x01, 0x00, /* supported settings */
5591         0x80, 0x00, 0x00, 0x00, /* current settings */
5592         0x09, 0x00, /* eir length */
5593         0x04, /* dev class length */
5594         0x0d, /* dev class info */
5595         0x00, /* minor */
5596         0x00, /* major */
5597         0x00, /* service classes */
5598         0x01, /* complete name data length */
5599         0x09, /* complete name flag */
5600         0x01, /* short name data length */
5601         0x08, /* short name flag */
5602 };
5603
5604 static const struct generic_data read_ext_ctrl_info1 = {
5605         .send_opcode = MGMT_OP_READ_EXT_INFO,
5606         .expect_status = MGMT_STATUS_SUCCESS,
5607         .expect_param = ext_ctrl_info1,
5608         .expect_len = sizeof(ext_ctrl_info1),
5609 };
5610
5611 static const char set_dev_class1[] = { 0x03, 0xe0 };
5612
5613 static const struct setup_mgmt_cmd set_dev_class_cmd_arr1[] = {
5614         {
5615                 .send_opcode = MGMT_OP_SET_DEV_CLASS,
5616                 .send_param = set_dev_class1,
5617                 .send_len = sizeof(set_dev_class1),
5618         },
5619         {
5620                 .send_opcode = MGMT_OP_ADD_UUID,
5621                 .send_param = add_spp_uuid_param,
5622                 .send_len = sizeof(add_spp_uuid_param),
5623         },
5624         { /* last element should always have opcode 0x00 */
5625                 .send_opcode = 0x00,
5626                 .send_param = NULL,
5627                 .send_len = 0,
5628         }
5629 };
5630
5631 static const char ext_ctrl_info2[] = {
5632         0x00, 0x00, 0x00, 0x01, 0xaa, 0x00, /* btaddr */
5633         0x09, /* version */
5634         0xf1, 0x05, /* manufacturer */
5635         0xff, 0xbf, 0x01, 0x00, /* supported settings */
5636         0x81, 0x02, 0x00, 0x00, /* current settings */
5637         0x0D, 0x00, /* eir length */
5638         0x04, /* dev class length */
5639         0x0d, /* dev class info */
5640         0xe0, /* minor */
5641         0x03, /* major */
5642         0x00, /* service classes */
5643         0x03, /* appearance length */
5644         0x19, /* EIR_APPEARANCE */
5645         0x00, /* Appearance value */
5646         0x00,
5647         0x01, /* complete name data length */
5648         0x09, /* complete name flag */
5649         0x01, /* short name data length */
5650         0x08, /* short name flag */
5651 };
5652
5653 static const struct generic_data read_ext_ctrl_info2 = {
5654         .setup_settings = settings_powered_le,
5655         .setup_mgmt_cmd_arr = set_dev_class_cmd_arr1,
5656         .send_opcode = MGMT_OP_READ_EXT_INFO,
5657         .expect_status = MGMT_STATUS_SUCCESS,
5658         .expect_param = ext_ctrl_info2,
5659         .expect_len = sizeof(ext_ctrl_info2),
5660 };
5661
5662 static const char ext_ctrl_info3[] = {
5663         0x00, 0x00, 0x00, 0x01, 0xaa, 0x00, /* btaddr */
5664         0x09, /* version */
5665         0xf1, 0x05, /* manufacturer */
5666         0xff, 0xbf, 0x01, 0x00, /* supported settings */
5667         0x80, 0x02, 0x00, 0x00, /* current settings */
5668         0x16, 0x00, /* eir length */
5669         0x04, /* dev class length */
5670         0x0d, /* dev class info */
5671         0x00, /* minor */
5672         0x00, /* major */
5673         0x00, /* service classes */
5674         0x03, /* appearance length */
5675         0x19, /* EIR_APPEARANCE */
5676         0x00, /* Appearance value */
5677         0x00,
5678         0x0A, /* Local name length */
5679         0x09, /* Complete name */
5680         0x54, 0x65, 0x73, 0x74,
5681         0x20, 0x6E, 0x61, 0x6D, 0x65, /* "Test name" */
5682         0x01, /* short name data length */
5683         0x08, /* short name flag */
5684 };
5685
5686 static const struct generic_data read_ext_ctrl_info3 = {
5687         .setup_settings = settings_le,
5688         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
5689         .setup_send_param = set_local_name_param,
5690         .setup_send_len = sizeof(set_local_name_param),
5691         .send_opcode = MGMT_OP_READ_EXT_INFO,
5692         .expect_status = MGMT_STATUS_SUCCESS,
5693         .expect_param = ext_ctrl_info3,
5694         .expect_len = sizeof(ext_ctrl_info3),
5695 };
5696
5697 static const char ext_ctrl_info4[] = {
5698         0x00, 0x00, 0x00, 0x01, 0xaa, 0x00, /* btaddr */
5699         0x09, /* version */
5700         0xf1, 0x05, /* manufacturer */
5701         0xff, 0xbf, 0x01, 0x00, /* supported settings */
5702         0x80, 0x02, 0x00, 0x00, /* current settings */
5703         0x1a, 0x00, /* eir length */
5704         0x04, /* dev class length */
5705         0x0d, /* dev class info */
5706         0x00, /* minor */
5707         0x00, /* major */
5708         0x00, /* service classes */
5709         0x03, /* appearance length */
5710         0x19, /* EIR_APPEARANCE */
5711         0x00, /* Appearance value */
5712         0x00,
5713         0x0A, /* Complete Local name len */
5714         0x09, /* Complete name */
5715         0x54, 0x65, 0x73, 0x74,
5716         0x20, 0x6E, 0x61, 0x6D, 0x65, /* "Test name" */
5717         0x05, /* Short Local name len */
5718         0x08, /* Short name */
5719         0x54, 0x65, 0x73, 0x74, /* "Test" */
5720 };
5721
5722 static const struct generic_data read_ext_ctrl_info4 = {
5723         .setup_settings = settings_le,
5724         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
5725         .setup_send_param = &set_local_name_cp,
5726         .setup_send_len = sizeof(set_local_name_cp),
5727         .send_opcode = MGMT_OP_READ_EXT_INFO,
5728         .expect_status = MGMT_STATUS_SUCCESS,
5729         .expect_param = ext_ctrl_info4,
5730         .expect_len = sizeof(ext_ctrl_info4),
5731 };
5732
5733 static const struct setup_mgmt_cmd set_dev_class_cmd_arr2[] = {
5734         {
5735                 .send_opcode = MGMT_OP_SET_DEV_CLASS,
5736                 .send_param = set_dev_class1,
5737                 .send_len = sizeof(set_dev_class1),
5738         },
5739         {
5740                 .send_opcode = MGMT_OP_ADD_UUID,
5741                 .send_param = add_spp_uuid_param,
5742                 .send_len = sizeof(add_spp_uuid_param),
5743         },
5744         {
5745                 .send_opcode = MGMT_OP_SET_LOCAL_NAME,
5746                 .send_param = &set_local_name_cp,
5747                 .send_len = sizeof(set_local_name_cp),
5748         },
5749         { /* last element should always have opcode 0x00 */
5750                 .send_opcode = 0x00,
5751                 .send_param = NULL,
5752                 .send_len = 0,
5753         }
5754 };
5755
5756 static const char ext_ctrl_info5[] = {
5757         0x00, 0x00, 0x00, 0x01, 0xaa, 0x00, /* btaddr */
5758         0x09, /* version */
5759         0xf1, 0x05, /* manufacturer */
5760         0xff, 0xbf, 0x01, 0x00, /* supported settings */
5761         0x81, 0x02, 0x00, 0x00, /* current settings */
5762         0x1a, 0x00, /* eir len */
5763         0x04, /* dev class len */
5764         0x0d, /* dev class info */
5765         0xe0, /* minor */
5766         0x03, /* major */
5767         0x00, /* service classes */
5768         0x03, /* appearance length */
5769         0x19, /* EIR_APPEARANCE */
5770         0x00, /* Appearance value */
5771         0x00,
5772         0x0A, /* Complete Local name len */
5773         0x09, /* Complete name */
5774         0x54, 0x65, 0x73, 0x74,
5775         0x20, 0x6E, 0x61, 0x6D, 0x65, /* "Test name" */
5776         0x05, /* Short Local name len */
5777         0x08, /* Short name */
5778         0x54, 0x65, 0x73, 0x74, /* "Test" */
5779 };
5780
5781 static const struct generic_data read_ext_ctrl_info5 = {
5782         .setup_settings = settings_powered_le,
5783         .setup_mgmt_cmd_arr = set_dev_class_cmd_arr2,
5784         .send_opcode = MGMT_OP_READ_EXT_INFO,
5785         .expect_status = MGMT_STATUS_SUCCESS,
5786         .expect_param = ext_ctrl_info5,
5787         .expect_len = sizeof(ext_ctrl_info5),
5788 };
5789
5790 static const struct generic_data read_controller_cap_invalid_param_test = {
5791         .send_opcode = MGMT_OP_READ_CONTROLLER_CAP,
5792         .send_param = dummy_data,
5793         .send_len = sizeof(dummy_data),
5794         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5795 };
5796
5797 static const struct generic_data read_controller_cap_success = {
5798         .send_opcode = MGMT_OP_READ_CONTROLLER_CAP,
5799         .expect_ignore_param = true,
5800         .expect_status = MGMT_STATUS_SUCCESS,
5801 };
5802
5803 static const char ext_adv_params_valid[] = {
5804         0x01, /* instance */
5805         0x00, 0xC0, 0x00, 0x00, /* flags, use tx power and intervals */
5806         0x00, 0x00, /* duration */
5807         0x00, 0x00, /* timeout */
5808         0xA0, 0x00, 0x00, 0x00, /* min_interval */
5809         0xA0, 0x00, 0x00, 0x00, /* max_interval */
5810         0x7f, /* tx_power */
5811 };
5812
5813 static const char ext_adv_hci_params_valid[] = {
5814         0x01, /* handle */
5815         0x10, 0x00, /* evt_properties */
5816         0xA0, 0x00, 0x00, /* min_interval */
5817         0xA0, 0x00, 0x00, /* max_interval */
5818         0x07, /* channel_map */
5819         0x01, /* own_addr_type */
5820         0x00, /* peer_addr_type */
5821         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* peer_addr */
5822         0x00, /* filter_policy */
5823         0x7f, /* tx_power */
5824         0x01, /* primary_phy */
5825         0x00, /* secondary_max_skip */
5826         0x01, /* secondary_phy */
5827         0x00, /* sid */
5828         0x00, /* notif_enable */
5829 };
5830
5831 static const char ext_adv_params_mgmt_rsp_valid_50[] = {
5832         0x01, /* instance */
5833         0x00, /* tx_power defaults to 0 on BT5 platform*/
5834         0x1f, /* max_adv_data_len */
5835         0x1f, /* max_scan_rsp_len */
5836 };
5837
5838 static const char ext_adv_params_mgmt_rsp_valid[] = {
5839         0x01, /* instance */
5840         0x7f, /* tx_power */
5841         0x1f, /* max_adv_data_len */
5842         0x1f, /* max_scan_rsp_len */
5843 };
5844
5845 static const char ext_adv_data_mgmt_rsp_valid[] = {
5846         0x01, /* instance */
5847 };
5848
5849 static const uint8_t ext_adv_data_valid[] = {
5850         0x01, /* instance */
5851         0x04, /* Ad data len */
5852         0x06, /* Scan response data len */
5853         0x03, /* Section length */
5854         0x19, /* GAP Appearance */
5855         0x01,
5856         0x23,
5857         0x05, /* Section length */
5858         0x08, /* ad type Short Name */
5859         't',
5860         'e',
5861         's',
5862         't',
5863 };
5864
5865 static const char ext_adv_hci_ad_data_valid[] = {
5866         0x01, /* handle */
5867         0x03, /* operation */
5868         0x01, /* minimize fragmentation */
5869         0x04, /* data length */
5870         0x03, /* Section length */
5871         0x19, /* GAP Appearance */
5872         0x01,
5873         0x23,
5874 };
5875
5876 static const char ext_adv_hci_scan_rsp_data_valid[] = {
5877         0x01, /* handle */
5878         0x03, /* operation */
5879         0x01, /* minimize fragmentation */
5880         0x06,
5881         0x05, /* Section length */
5882         0x08, /* ad type Short Name */
5883         't',
5884         'e',
5885         's',
5886         't',
5887 };
5888
5889 static const uint8_t ext_adv_data_invalid[] = {
5890         0x01, /* instance */
5891         0x04, /* Ad data len */
5892         0x06, /* Scan response data len */
5893         0x03, /* Section length */
5894         0x19, /* GAP Appearance */
5895         0x01,
5896         0x23,
5897         0x07, /* Section length purposefully two octets too long */
5898         0x08, /* ad type Short Name */
5899         't',
5900         'e',
5901         's',
5902         't',
5903 };
5904
5905 static const struct generic_data adv_params_fail_unpowered = {
5906         .setup_settings = settings_le, /* Unpowered */
5907         .send_opcode = MGMT_OP_ADD_EXT_ADV_PARAMS,
5908         .send_param = ext_adv_params_valid,
5909         .send_len = sizeof(ext_adv_params_valid),
5910         .expect_status = MGMT_STATUS_REJECTED,
5911 };
5912
5913 static const struct generic_data adv_params_fail_invalid_params = {
5914         .setup_settings = settings_powered_le,
5915         .send_opcode = MGMT_OP_ADD_EXT_ADV_PARAMS,
5916         .send_param = dummy_data,
5917         .send_len = sizeof(dummy_data),
5918         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5919 };
5920
5921 static const struct generic_data adv_params_success = {
5922         .setup_settings = settings_powered_le,
5923         .send_opcode = MGMT_OP_ADD_EXT_ADV_PARAMS,
5924         .send_param = ext_adv_params_valid,
5925         .send_len = sizeof(ext_adv_params_valid),
5926         .expect_param = ext_adv_params_mgmt_rsp_valid,
5927         .expect_len = sizeof(ext_adv_params_mgmt_rsp_valid),
5928         .expect_status = MGMT_STATUS_SUCCESS,
5929 };
5930
5931 static const struct generic_data adv_params_success_50 = {
5932         .setup_settings = settings_powered_le,
5933         .send_opcode = MGMT_OP_ADD_EXT_ADV_PARAMS,
5934         .send_param = ext_adv_params_valid,
5935         .send_len = sizeof(ext_adv_params_valid),
5936         .expect_status = MGMT_STATUS_SUCCESS,
5937         .expect_param = ext_adv_params_mgmt_rsp_valid_50,
5938         .expect_len = sizeof(ext_adv_params_mgmt_rsp_valid_50),
5939         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
5940         .expect_hci_param = ext_adv_hci_params_valid,
5941         .expect_hci_len = sizeof(ext_adv_hci_params_valid),
5942 };
5943
5944 static const struct generic_data adv_data_fail_no_params = {
5945         .setup_settings = settings_powered_le,
5946         .send_opcode = MGMT_OP_ADD_EXT_ADV_DATA,
5947         .send_param = ext_adv_data_valid,
5948         .send_len = sizeof(ext_adv_data_valid),
5949         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5950 };
5951
5952 static const struct generic_data adv_data_success = {
5953         .setup_settings = settings_powered_le,
5954         .send_opcode = MGMT_OP_ADD_EXT_ADV_DATA,
5955         .send_param = ext_adv_data_valid,
5956         .send_len = sizeof(ext_adv_data_valid),
5957         .expect_status = MGMT_STATUS_SUCCESS,
5958         .expect_param = ext_adv_data_mgmt_rsp_valid,
5959         .expect_len = sizeof(ext_adv_data_mgmt_rsp_valid),
5960         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
5961         .expect_hci_param = ext_adv_hci_ad_data_valid,
5962         .expect_hci_len = sizeof(ext_adv_hci_ad_data_valid),
5963 };
5964
5965 static const struct generic_data adv_scan_rsp_success = {
5966         .setup_settings = settings_powered_le,
5967         .send_opcode = MGMT_OP_ADD_EXT_ADV_DATA,
5968         .send_param = ext_adv_data_valid,
5969         .send_len = sizeof(ext_adv_data_valid),
5970         .expect_status = MGMT_STATUS_SUCCESS,
5971         .expect_param = ext_adv_data_mgmt_rsp_valid,
5972         .expect_len = sizeof(ext_adv_data_mgmt_rsp_valid),
5973         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
5974         .expect_hci_param = ext_adv_hci_scan_rsp_data_valid,
5975         .expect_hci_len = sizeof(ext_adv_hci_scan_rsp_data_valid),
5976 };
5977
5978 static const struct generic_data adv_data_invalid_params = {
5979         .setup_settings = settings_powered_le,
5980         .send_opcode = MGMT_OP_ADD_EXT_ADV_DATA,
5981         .send_param = ext_adv_data_invalid,
5982         .send_len = sizeof(ext_adv_data_invalid),
5983         .expect_status = MGMT_STATUS_INVALID_PARAMS,
5984 };
5985
5986 static const uint8_t set_dev_id_param_success_1[] = {
5987         0x01, /* Source - 0x0001 (Bluetooth SIG) */
5988         0x00,
5989         0x02, /* Vendor */
5990         0x00,
5991         0xcd, /* Product */
5992         0xab,
5993         0x34,
5994         0x12, /* Version */
5995 };
5996
5997 static const char write_eir_set_dev_id_success_1[241] = {
5998                         0x00, 0x02, 0x0a, 0x00, 0x09, 0x10, 0x01, 0x00,
5999                         0x02, 0x00, 0xcd, 0xab, 0x34, 0x12 };
6000
6001 static const struct generic_data set_dev_id_success_1 = {
6002         .setup_settings = settings_powered_ssp,
6003         .send_opcode = MGMT_OP_SET_DEVICE_ID,
6004         .send_param = set_dev_id_param_success_1,
6005         .send_len = sizeof(set_dev_id_param_success_1),
6006         .expect_status = MGMT_STATUS_SUCCESS,
6007         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
6008         .expect_hci_param = write_eir_set_dev_id_success_1,
6009         .expect_hci_len = sizeof(write_eir_set_dev_id_success_1),
6010 };
6011
6012 static const uint8_t set_dev_id_param_success_2[] = {
6013         0x02, /* Source - 0x0001 (Bluetooth SIG) */
6014         0x00,
6015         0x02, /* Vendor */
6016         0x00,
6017         0xcd, /* Product */
6018         0xab,
6019         0x34,
6020         0x12, /* Version */
6021 };
6022 static const char write_eir_set_dev_id_success_2[241] = {
6023                         0x00, 0x02, 0x0a, 0x00, 0x09, 0x10, 0x02, 0x00,
6024                         0x02, 0x00, 0xcd, 0xab, 0x34, 0x12 };
6025
6026 static const struct generic_data set_dev_id_success_2 = {
6027         .setup_settings = settings_powered_ssp,
6028         .send_opcode = MGMT_OP_SET_DEVICE_ID,
6029         .send_param = set_dev_id_param_success_2,
6030         .send_len = sizeof(set_dev_id_param_success_2),
6031         .expect_status = MGMT_STATUS_SUCCESS,
6032         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
6033         .expect_hci_param = write_eir_set_dev_id_success_2,
6034         .expect_hci_len = sizeof(write_eir_set_dev_id_success_2),
6035 };
6036
6037 static const uint8_t set_dev_id_param_disable[8] = { 0x00 };
6038
6039 static const struct generic_data set_dev_id_disable = {
6040         .setup_settings = settings_powered_ssp,
6041         .send_opcode = MGMT_OP_SET_DEVICE_ID,
6042         .send_param = set_dev_id_param_disable,
6043         .send_len = sizeof(set_dev_id_param_disable),
6044         .expect_status = MGMT_STATUS_SUCCESS,
6045 };
6046
6047 static const struct generic_data set_dev_id_power_off_on = {
6048         .setup_settings = settings_ssp,
6049         .setup_send_opcode = MGMT_OP_SET_DEVICE_ID,
6050         .setup_send_param = set_dev_id_param_success_1,
6051         .setup_send_len = sizeof(set_dev_id_param_success_1),
6052         .send_opcode = MGMT_OP_SET_POWERED,
6053         .send_param = set_powered_on_param,
6054         .send_len = sizeof(set_powered_on_param),
6055         .expect_status = MGMT_STATUS_SUCCESS,
6056         .expect_param = set_ssp_settings_param_2,
6057         .expect_len = sizeof(set_ssp_settings_param_2),
6058         .expect_settings_set = MGMT_SETTING_POWERED,
6059         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
6060         .expect_hci_param = write_eir_set_dev_id_success_1,
6061         .expect_hci_len = sizeof(write_eir_set_dev_id_success_1),
6062 };
6063
6064 static const struct generic_data set_dev_id_ssp_off_on = {
6065         .setup_settings = settings_powered,
6066         .setup_send_opcode = MGMT_OP_SET_DEVICE_ID,
6067         .setup_send_param = set_dev_id_param_success_1,
6068         .setup_send_len = sizeof(set_dev_id_param_success_1),
6069         .send_opcode = MGMT_OP_SET_SSP,
6070         .send_param = set_ssp_on_param,
6071         .send_len = sizeof(set_ssp_on_param),
6072         .expect_status = MGMT_STATUS_SUCCESS,
6073         .expect_param = set_ssp_settings_param_2,
6074         .expect_len = sizeof(set_ssp_settings_param_2),
6075         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
6076         .expect_hci_param = write_eir_set_dev_id_success_1,
6077         .expect_hci_len = sizeof(write_eir_set_dev_id_success_1),
6078 };
6079
6080 static const uint8_t set_dev_id_invalid_1[] = {
6081         0x03, /* Source */
6082         0x00,
6083         0x02, /* Vendor */
6084         0x00,
6085         0xcd, /* Product */
6086         0xab,
6087         0x34,
6088         0x12, /* Version */
6089 };
6090
6091 static const struct generic_data set_dev_id_invalid_param = {
6092         .setup_settings = settings_powered_ssp,
6093         .send_opcode = MGMT_OP_SET_DEVICE_ID,
6094         .send_param = set_dev_id_invalid_1,
6095         .send_len = sizeof(set_dev_id_invalid_1),
6096         .expect_status = MGMT_STATUS_INVALID_PARAMS,
6097 };
6098
6099 static void client_cmd_complete(uint16_t opcode, uint8_t status,
6100                                         const void *param, uint8_t len,
6101                                         void *user_data)
6102 {
6103         struct test_data *data = tester_get_data();
6104         const struct generic_data *test = data->test_data;
6105         struct bthost *bthost;
6106
6107         bthost = hciemu_client_get_host(data->hciemu);
6108
6109         switch (opcode) {
6110         case BT_HCI_CMD_WRITE_SCAN_ENABLE:
6111         case BT_HCI_CMD_LE_SET_ADV_ENABLE:
6112         case BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE:
6113                 tester_print("Client set connectable: %s (0x%02x)",
6114                                                 mgmt_errstr(status), status);
6115                 if (!status && test->client_enable_ssp) {
6116                         bthost_write_ssp_mode(bthost, 0x01);
6117                         return;
6118                 }
6119                 break;
6120         case BT_HCI_CMD_WRITE_SIMPLE_PAIRING_MODE:
6121                 tester_print("Client enable SSP: %s (0x%02x)",
6122                                                 mgmt_errstr(status), status);
6123                 break;
6124         default:
6125                 return;
6126         }
6127
6128         if (status)
6129                 tester_setup_failed();
6130         else
6131                 test_setup_condition_complete(data);
6132 }
6133
6134 static void setup_bthost(void)
6135 {
6136         struct test_data *data = tester_get_data();
6137         const struct generic_data *test = data->test_data;
6138         struct bthost *bthost;
6139
6140         bthost = hciemu_client_get_host(data->hciemu);
6141         bthost_set_cmd_complete_cb(bthost, client_cmd_complete, data);
6142         test_add_setup_condition(data);
6143
6144         if (data->hciemu_type == HCIEMU_TYPE_LE ||
6145                 test->client_enable_adv) {
6146                 if (data->hciemu_type >= HCIEMU_TYPE_BREDRLE50) {
6147                         bthost_set_ext_adv_params(bthost);
6148                         bthost_set_ext_adv_enable(bthost, 0x01);
6149                 } else
6150                         bthost_set_adv_enable(bthost, 0x01);
6151         } else
6152                 bthost_write_scan_enable(bthost, 0x03);
6153 }
6154
6155 static void setup_pairing_acceptor(const void *test_data)
6156 {
6157         struct test_data *data = tester_get_data();
6158         const struct generic_data *test = data->test_data;
6159
6160         if (!test->io_cap)
6161                 return;
6162
6163         mgmt_send(data->mgmt, MGMT_OP_SET_IO_CAPABILITY, data->mgmt_index,
6164                                         sizeof(test->io_cap), &test->io_cap,
6165                                         NULL, NULL, NULL);
6166
6167         setup_bthost();
6168 }
6169
6170 static void setup_powered_callback(uint8_t status, uint16_t length,
6171                                         const void *param, void *user_data)
6172 {
6173         if (status != MGMT_STATUS_SUCCESS) {
6174                 tester_setup_failed();
6175                 return;
6176         }
6177
6178         tester_print("Controller powered on");
6179
6180         setup_bthost();
6181 }
6182
6183 static void setup_class(const void *test_data)
6184 {
6185         struct test_data *data = tester_get_data();
6186         unsigned char param[] = { 0x01 };
6187         unsigned char class_param[] = { 0x01, 0x0c };
6188
6189         tester_print("Setting device class and powering on");
6190
6191         mgmt_send(data->mgmt, MGMT_OP_SET_DEV_CLASS, data->mgmt_index,
6192                                 sizeof(class_param), class_param,
6193                                 NULL, NULL, NULL);
6194
6195         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6196                                         sizeof(param), param,
6197                                         setup_powered_callback, NULL, NULL);
6198 }
6199
6200 static void discovering_event(uint16_t index, uint16_t length,
6201                                         const void *param, void *user_data)
6202 {
6203         struct test_data *data = tester_get_data();
6204         const struct mgmt_ev_discovering *ev = param;
6205
6206         mgmt_unregister(data->mgmt, data->mgmt_discov_ev_id);
6207
6208         if (length != sizeof(*ev)) {
6209                 tester_warn("Incorrect discovering event length");
6210                 tester_setup_failed();
6211                 return;
6212         }
6213
6214         if (!ev->discovering) {
6215                 tester_warn("Unexpected discovery stopped event");
6216                 tester_setup_failed();
6217                 return;
6218         }
6219
6220         tester_setup_complete();
6221 }
6222
6223 static void setup_discovery_callback(uint8_t status, uint16_t length,
6224                                         const void *param, void *user_data)
6225 {
6226         if (status != MGMT_STATUS_SUCCESS) {
6227                 tester_setup_failed();
6228                 return;
6229         }
6230
6231         tester_print("Discovery started");
6232 }
6233
6234 static void setup_start_discovery(const void *test_data)
6235 {
6236         struct test_data *data = tester_get_data();
6237         const struct generic_data *test = data->test_data;
6238         const void *send_param = test->setup_send_param;
6239         uint16_t send_len = test->setup_send_len;
6240         unsigned int id;
6241
6242         id = mgmt_register(data->mgmt, MGMT_EV_DISCOVERING, data->mgmt_index,
6243                            discovering_event, NULL, NULL);
6244         data->mgmt_discov_ev_id = id;
6245
6246         mgmt_send(data->mgmt, test->setup_send_opcode, data->mgmt_index,
6247                                 send_len, send_param, setup_discovery_callback,
6248                                 NULL, NULL);
6249 }
6250
6251 static void setup_multi_uuid32(const void *test_data)
6252 {
6253         struct test_data *data = tester_get_data();
6254         unsigned char param[] = { 0x01 };
6255
6256         tester_print("Powering on controller (with 32-bit UUID)");
6257
6258         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6259                                 sizeof(param), param, NULL, NULL, NULL);
6260
6261         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6262                                 sizeof(add_uuid32_param_1), add_uuid32_param_1,
6263                                 NULL, NULL, NULL);
6264         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6265                                 sizeof(add_uuid32_param_2), add_uuid32_param_2,
6266                                 NULL, NULL, NULL);
6267         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6268                                 sizeof(add_uuid32_param_3), add_uuid32_param_3,
6269                                 NULL, NULL, NULL);
6270
6271         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6272                                         sizeof(param), param,
6273                                         setup_powered_callback, NULL, NULL);
6274 }
6275
6276 static void setup_multi_uuid32_2(const void *test_data)
6277 {
6278         struct test_data *data = tester_get_data();
6279         unsigned char param[] = { 0x01 };
6280         unsigned char uuid_param[] = {
6281                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
6282                         0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6283                         0x00 };
6284         int i;
6285
6286         tester_print("Powering on controller (with many 32-bit UUIDs)");
6287
6288         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6289                                 sizeof(param), param, NULL, NULL, NULL);
6290
6291         for (i = 0; i < 58; i++) {
6292                 uint32_t val = htobl(0xffffffff - i);
6293                 memcpy(&uuid_param[12], &val, sizeof(val));
6294                 mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6295                                 sizeof(uuid_param), uuid_param,
6296                                 NULL, NULL, NULL);
6297         }
6298
6299         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6300                                         sizeof(param), param,
6301                                         setup_powered_callback, NULL, NULL);
6302 }
6303
6304 static void setup_multi_uuid128(const void *test_data)
6305 {
6306         struct test_data *data = tester_get_data();
6307         unsigned char param[] = { 0x01 };
6308
6309         tester_print("Powering on controller (with 128-bit UUID)");
6310
6311         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6312                                 sizeof(param), param, NULL, NULL, NULL);
6313
6314         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6315                         sizeof(add_uuid128_param_1), add_uuid128_param_1,
6316                         NULL, NULL, NULL);
6317
6318         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6319                                         sizeof(param), param,
6320                                         setup_powered_callback, NULL, NULL);
6321 }
6322
6323 static void setup_multi_uuid128_2(const void *test_data)
6324 {
6325         struct test_data *data = tester_get_data();
6326         unsigned char param[] = { 0x01 };
6327         unsigned char uuid_param[] = {
6328                         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
6329                         0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00,
6330                         0x00 };
6331         int i;
6332
6333         tester_print("Powering on controller (with many 128-bit UUIDs)");
6334
6335         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6336                                 sizeof(param), param, NULL, NULL, NULL);
6337
6338         for (i = 0; i < 13; i++) {
6339                 uuid_param[15] = i;
6340                 mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6341                                 sizeof(uuid_param), uuid_param,
6342                                 NULL, NULL, NULL);
6343         }
6344
6345         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6346                                         sizeof(param), param,
6347                                         setup_powered_callback, NULL, NULL);
6348 }
6349
6350 static void setup_multi_uuid16(const void *test_data)
6351 {
6352         struct test_data *data = tester_get_data();
6353         unsigned char param[] = { 0x01 };
6354
6355         tester_print("Powering on controller (with SPP UUID)");
6356
6357         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6358                                 sizeof(param), param, NULL, NULL, NULL);
6359
6360         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6361                                 sizeof(add_spp_uuid_param), add_spp_uuid_param,
6362                                 NULL, NULL, NULL);
6363         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6364                                 sizeof(add_dun_uuid_param), add_dun_uuid_param,
6365                                 NULL, NULL, NULL);
6366         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6367                         sizeof(add_sync_uuid_param), add_sync_uuid_param,
6368                         NULL, NULL, NULL);
6369
6370         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6371                                         sizeof(param), param,
6372                                         setup_powered_callback, NULL, NULL);
6373 }
6374
6375 static void setup_multi_uuid16_power_off(const void *test_data)
6376 {
6377         struct test_data *data = tester_get_data();
6378         unsigned char param[] = { 0x01 };
6379
6380         tester_print("Adding UUIDs without powering on");
6381
6382         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6383                                 sizeof(param), param, NULL, NULL, NULL);
6384
6385         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6386                                 sizeof(add_spp_uuid_param), add_spp_uuid_param,
6387                                 NULL, NULL, NULL);
6388         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6389                                 sizeof(add_dun_uuid_param), add_dun_uuid_param,
6390                                 NULL, NULL, NULL);
6391         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6392                         sizeof(add_sync_uuid_param), add_sync_uuid_param,
6393                         NULL, NULL, NULL);
6394
6395         setup_bthost();
6396 }
6397
6398 static void setup_multi_uuid16_power_off_remove(const void *test_data)
6399 {
6400         struct test_data *data = tester_get_data();
6401         unsigned char param[] = { 0x01 };
6402
6403         tester_print("Adding UUIDs without powering on and remove UUID");
6404
6405         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6406                                 sizeof(param), param, NULL, NULL, NULL);
6407
6408         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6409                                 sizeof(add_spp_uuid_param), add_spp_uuid_param,
6410                                 NULL, NULL, NULL);
6411         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6412                                 sizeof(add_dun_uuid_param), add_dun_uuid_param,
6413                                 NULL, NULL, NULL);
6414         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6415                         sizeof(add_sync_uuid_param), add_sync_uuid_param,
6416                         NULL, NULL, NULL);
6417
6418         mgmt_send(data->mgmt, MGMT_OP_REMOVE_UUID, data->mgmt_index,
6419                         sizeof(remove_dun_uuid_param), remove_dun_uuid_param,
6420                         NULL, NULL, NULL);
6421
6422         setup_bthost();
6423 }
6424
6425 static void setup_multi_uuid16_2(const void *test_data)
6426 {
6427         struct test_data *data = tester_get_data();
6428         unsigned char param[] = { 0x01 };
6429         unsigned char uuid_param[] = {
6430                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
6431                         0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6432                         0x00 };
6433         int i;
6434
6435         tester_print("Powering on controller (with many 16-bit UUIDs)");
6436
6437         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6438                                 sizeof(param), param, NULL, NULL, NULL);
6439
6440         for (i = 0; i < 117; i++) {
6441                 uint16_t val = htobs(i + 0x2000);
6442                 memcpy(&uuid_param[12], &val, sizeof(val));
6443                 mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6444                                 sizeof(uuid_param), uuid_param,
6445                                 NULL, NULL, NULL);
6446         }
6447
6448         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6449                                         sizeof(param), param,
6450                                         setup_powered_callback, NULL, NULL);
6451 }
6452
6453 static void setup_uuid_mix(const void *test_data)
6454 {
6455         struct test_data *data = tester_get_data();
6456         unsigned char param[] = { 0x01 };
6457
6458         tester_print("Powering on controller (with mixed UUIDs)");
6459
6460         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
6461                                 sizeof(param), param, NULL, NULL, NULL);
6462
6463         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6464                                 sizeof(add_spp_uuid_param), add_spp_uuid_param,
6465                                 NULL, NULL, NULL);
6466         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6467                                 sizeof(add_uuid32_param_1), add_uuid32_param_1,
6468                                 NULL, NULL, NULL);
6469         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6470                         sizeof(add_uuid128_param_1), add_uuid128_param_1,
6471                         NULL, NULL, NULL);
6472
6473         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6474                                 sizeof(add_dun_uuid_param), add_dun_uuid_param,
6475                                 NULL, NULL, NULL);
6476         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
6477                                 sizeof(add_uuid32_param_2), add_uuid32_param_2,
6478                                 NULL, NULL, NULL);
6479
6480         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6481                                         sizeof(param), param,
6482                                         setup_powered_callback, NULL, NULL);
6483 }
6484
6485 static void setup_load_ltks_callback(uint8_t status, uint16_t length,
6486                                         const void *param, void *user_data)
6487 {
6488         if (status != MGMT_STATUS_SUCCESS) {
6489                 tester_setup_failed();
6490                 return;
6491         }
6492
6493         tester_print("Loaded Long Term Key");
6494 }
6495
6496 static void setup_load_ltks_20_by_1(const void *test_data)
6497 {
6498         struct test_data *data = tester_get_data();
6499         struct mgmt_cp_load_long_term_keys *cp;
6500         struct mgmt_ltk_info *info;
6501         unsigned char param[sizeof(*cp) + sizeof(*info)] = { 0x00 };
6502         unsigned char param_on[] = { 0x01 };
6503         int i;
6504
6505         cp = (struct mgmt_cp_load_long_term_keys *)param;
6506         cp->key_count = 1;
6507
6508         info = (struct mgmt_ltk_info *)cp->keys;
6509         info->addr.type = 0x01;         /* LE Public */
6510
6511         for (i = 0; i < 20; i++) {
6512                 /* Update BDADDR */
6513                 info->addr.bdaddr.b[0] = i + 1;
6514
6515                 mgmt_send(data->mgmt, MGMT_OP_LOAD_LONG_TERM_KEYS,
6516                           data->mgmt_index, sizeof(param), param,
6517                           setup_load_ltks_callback, NULL, NULL);
6518         }
6519
6520         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6521                                         sizeof(param_on), param_on,
6522                                         setup_powered_callback, NULL, NULL);
6523 }
6524
6525 static void setup_add_device(const void *test_data)
6526 {
6527         struct test_data *data = tester_get_data();
6528         unsigned char param[] = { 0x01 };
6529         const unsigned char *add_param;
6530         size_t add_param_len;
6531
6532         tester_print("Powering on controller (with added device)");
6533
6534         if (data->hciemu_type == HCIEMU_TYPE_LE) {
6535                 add_param = add_device_success_param_2;
6536                 add_param_len = sizeof(add_device_success_param_2);
6537         } else {
6538                 add_param = add_device_success_param_1;
6539                 add_param_len = sizeof(add_device_success_param_1);
6540         }
6541
6542         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
6543                         add_param_len, add_param, NULL, NULL, NULL);
6544
6545         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6546                                         sizeof(param), param,
6547                                         setup_powered_callback, NULL, NULL);
6548 }
6549
6550 static void setup_add_advertising_callback(uint8_t status, uint16_t length,
6551                                         const void *param, void *user_data)
6552 {
6553         struct mgmt_rp_add_advertising *rp =
6554                                 (struct mgmt_rp_add_advertising *) param;
6555
6556         if (status != MGMT_STATUS_SUCCESS) {
6557                 tester_setup_failed();
6558                 return;
6559         }
6560
6561         tester_print("Add Advertising setup complete (instance %d)",
6562                                                                 rp->instance);
6563
6564         setup_bthost();
6565 }
6566
6567 #define TESTER_ADD_ADV_DATA_LEN 7
6568
6569 static void setup_add_adv_param(struct mgmt_cp_add_advertising *cp,
6570                                                         uint8_t instance)
6571 {
6572         memset(cp, 0, sizeof(*cp));
6573         cp->instance = instance;
6574         cp->adv_data_len = TESTER_ADD_ADV_DATA_LEN;
6575         cp->data[0] = TESTER_ADD_ADV_DATA_LEN - 1; /* AD len */
6576         cp->data[1] = 0x08; /* AD type: shortened local name */
6577         cp->data[2] = 't';  /* adv data ... */
6578         cp->data[3] = 'e';
6579         cp->data[4] = 's';
6580         cp->data[5] = 't';
6581         cp->data[6] = '0' + instance;
6582 }
6583
6584 static void setup_add_advertising_not_powered(const void *test_data)
6585 {
6586         struct test_data *data = tester_get_data();
6587         struct mgmt_cp_add_advertising *cp;
6588         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6589         unsigned char param[] = { 0x01 };
6590
6591         tester_print("Adding advertising instance while unpowered");
6592
6593         cp = (struct mgmt_cp_add_advertising *) adv_param;
6594         setup_add_adv_param(cp, 1);
6595
6596         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6597                                                 sizeof(param), &param,
6598                                                 NULL, NULL, NULL);
6599
6600         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6601                                                 sizeof(adv_param), adv_param,
6602                                                 setup_add_advertising_callback,
6603                                                 NULL, NULL);
6604 }
6605
6606 static void setup_add_advertising(const void *test_data)
6607 {
6608         struct test_data *data = tester_get_data();
6609         struct mgmt_cp_add_advertising *cp;
6610         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6611         unsigned char param[] = { 0x01 };
6612
6613         tester_print("Adding advertising instance while powered");
6614
6615         cp = (struct mgmt_cp_add_advertising *) adv_param;
6616         setup_add_adv_param(cp, 1);
6617
6618         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6619                                                 sizeof(param), &param,
6620                                                 NULL, NULL, NULL);
6621
6622         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6623                                                 sizeof(param), &param,
6624                                                 NULL, NULL, NULL);
6625
6626         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6627                                                 sizeof(adv_param), adv_param,
6628                                                 setup_add_advertising_callback,
6629                                                 NULL, NULL);
6630 }
6631
6632 static void setup_add_advertising_connectable(const void *test_data)
6633 {
6634         struct test_data *data = tester_get_data();
6635         struct mgmt_cp_add_advertising *cp;
6636         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6637         unsigned char param[] = { 0x01 };
6638
6639         tester_print("Adding advertising instance while connectable");
6640
6641         cp = (struct mgmt_cp_add_advertising *) adv_param;
6642         setup_add_adv_param(cp, 1);
6643
6644         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6645                                                 sizeof(param), &param,
6646                                                 NULL, NULL, NULL);
6647
6648         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6649                                                 sizeof(param), &param,
6650                                                 NULL, NULL, NULL);
6651
6652         mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
6653                                                 sizeof(param), &param,
6654                                                 NULL, NULL, NULL);
6655
6656         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6657                                                 sizeof(adv_param), adv_param,
6658                                                 setup_add_advertising_callback,
6659                                                 NULL, NULL);
6660 }
6661
6662 static int create_le_att_sock(struct test_data *data)
6663 {
6664         struct sockaddr_l2 addr;
6665         int sk, err;
6666
6667         sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET | SOCK_NONBLOCK,
6668                                                         BTPROTO_L2CAP);
6669         if (sk < 0) {
6670                 err = -errno;
6671                 tester_warn("Can't create socket: %s (%d)", strerror(errno),
6672                                                                         errno);
6673                 return err;
6674         }
6675
6676         memset(&addr, 0, sizeof(addr));
6677         addr.l2_family = AF_BLUETOOTH;
6678         addr.l2_psm = 0;
6679         addr.l2_cid = htobs(0x0004);
6680         addr.l2_bdaddr_type = BDADDR_LE_PUBLIC;
6681
6682         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
6683                 err = -errno;
6684                 tester_warn("Can't bind socket: %s (%d)", strerror(errno),
6685                                                                         errno);
6686                 close(sk);
6687                 return err;
6688         }
6689
6690         if (listen(sk, 1) < 0) {
6691                 err = -errno;
6692                 tester_warn("Can't bind socket: %s (%d)", strerror(errno),
6693                                                                         errno);
6694                 close(sk);
6695                 return err;
6696         }
6697
6698         data->sk = sk;
6699
6700         return sk;
6701 }
6702
6703 static void setup_advertise_while_connected(const void *test_data)
6704 {
6705         struct test_data *data = tester_get_data();
6706         struct mgmt_cp_add_advertising *cp;
6707         uint8_t adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6708
6709         tester_print("Adding advertising instances");
6710
6711         cp = (struct mgmt_cp_add_advertising *) adv_param;
6712         setup_add_adv_param(cp, 1);
6713
6714         cp->flags |= MGMT_ADV_FLAG_CONNECTABLE;
6715         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6716                                                 sizeof(adv_param), adv_param,
6717                                                 NULL, NULL, NULL);
6718
6719         cp->flags &= ~MGMT_ADV_FLAG_CONNECTABLE;
6720         cp->instance = 2;
6721
6722         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6723                                                 sizeof(adv_param), adv_param,
6724                                                 setup_add_advertising_callback,
6725                                                 NULL, NULL);
6726
6727         /* Listen on the socket so Kernel does not drop connection just after
6728          * connect. Socket is closed in test_post_teardown
6729          */
6730         if (create_le_att_sock(data) < 0)
6731                 tester_test_failed();
6732 }
6733
6734 static void setup_add_advertising_timeout(const void *test_data)
6735 {
6736         struct test_data *data = tester_get_data();
6737         struct mgmt_cp_add_advertising *cp;
6738         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6739         unsigned char param[] = { 0x01 };
6740
6741         tester_print("Adding advertising instance with timeout");
6742
6743         cp = (struct mgmt_cp_add_advertising *) adv_param;
6744         setup_add_adv_param(cp, 1);
6745         cp->timeout = 1;
6746
6747         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6748                                                 sizeof(param), &param,
6749                                                 NULL, NULL, NULL);
6750
6751         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6752                                                 sizeof(param), &param,
6753                                                 NULL, NULL, NULL);
6754
6755         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6756                                                 sizeof(adv_param), adv_param,
6757                                                 setup_add_advertising_callback,
6758                                                 NULL, NULL);
6759 }
6760
6761 static void setup_add_advertising_duration(const void *test_data)
6762 {
6763         struct test_data *data = tester_get_data();
6764         struct mgmt_cp_add_advertising *cp;
6765         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6766         unsigned char param[] = { 0x01 };
6767
6768         tester_print("Adding instance with long timeout/short duration");
6769
6770         cp = (struct mgmt_cp_add_advertising *) adv_param;
6771         setup_add_adv_param(cp, 1);
6772         cp->duration = 1;
6773         cp->timeout = 30;
6774
6775         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6776                                                 sizeof(param), &param,
6777                                                 NULL, NULL, NULL);
6778
6779         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6780                                                 sizeof(param), &param,
6781                                                 NULL, NULL, NULL);
6782
6783         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6784                                                 sizeof(adv_param), adv_param,
6785                                                 setup_add_advertising_callback,
6786                                                 NULL, NULL);
6787 }
6788
6789 static void setup_power_cycle_callback(uint8_t status, uint16_t length,
6790                                         const void *param, void *user_data)
6791 {
6792         struct test_data *data = tester_get_data();
6793         unsigned char param_off[] = { 0x00 };
6794
6795         if (status != MGMT_STATUS_SUCCESS) {
6796                 tester_setup_failed();
6797                 return;
6798         }
6799
6800         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6801                                                 sizeof(param_off), &param_off,
6802                                                 NULL, NULL, NULL);
6803
6804         setup_bthost();
6805 }
6806
6807 static void setup_add_advertising_power_cycle(const void *test_data)
6808 {
6809         struct test_data *data = tester_get_data();
6810         struct mgmt_cp_add_advertising *cp;
6811         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6812         unsigned char param_on[] = { 0x01 };
6813
6814         tester_print("Adding instance without timeout and power cycle");
6815
6816         cp = (struct mgmt_cp_add_advertising *) adv_param;
6817         setup_add_adv_param(cp, 1);
6818
6819         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6820                                                 sizeof(param_on), &param_on,
6821                                                 NULL, NULL, NULL);
6822
6823         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6824                                                 sizeof(param_on), &param_on,
6825                                                 NULL, NULL, NULL);
6826
6827         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6828                                                 sizeof(adv_param), adv_param,
6829                                                 setup_power_cycle_callback,
6830                                                 NULL, NULL);
6831 }
6832
6833 static void setup_set_and_add_advertising(const void *test_data)
6834 {
6835         struct test_data *data = tester_get_data();
6836         struct mgmt_cp_add_advertising *cp;
6837         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6838         unsigned char param[] = { 0x01 };
6839
6840         tester_print("Set and add advertising instance");
6841
6842         cp = (struct mgmt_cp_add_advertising *) adv_param;
6843         setup_add_adv_param(cp, 1);
6844
6845         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6846                                                 sizeof(param), &param,
6847                                                 NULL, NULL, NULL);
6848
6849         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6850                                                 sizeof(param), &param,
6851                                                 NULL, NULL, NULL);
6852
6853         mgmt_send(data->mgmt, MGMT_OP_SET_ADVERTISING, data->mgmt_index,
6854                                                 sizeof(param), &param,
6855                                                 NULL, NULL, NULL);
6856
6857         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6858                                                 sizeof(adv_param), adv_param,
6859                                                 setup_add_advertising_callback,
6860                                                 NULL, NULL);
6861 }
6862
6863 static void setup_multi_adv_second_instance(uint8_t status, uint16_t length,
6864                 const void *param, void *user_data) {
6865         struct mgmt_rp_add_advertising *rp =
6866                                 (struct mgmt_rp_add_advertising *) param;
6867         struct test_data *data = tester_get_data();
6868         struct mgmt_cp_add_advertising *cp;
6869         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6870
6871         if (status != MGMT_STATUS_SUCCESS) {
6872                 tester_setup_failed();
6873                 return;
6874         }
6875
6876         tester_print("Add Advertising setup complete (instance %d)",
6877                                                                 rp->instance);
6878
6879         cp = (struct mgmt_cp_add_advertising *) adv_param;
6880         setup_add_adv_param(cp, 2);
6881         cp->timeout = 1;
6882         cp->duration = 1;
6883
6884         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6885                                                 sizeof(adv_param), adv_param,
6886                                                 setup_add_advertising_callback,
6887                                                 NULL, NULL);
6888 }
6889
6890 static void setup_multi_adv(const void *test_data)
6891 {
6892         struct test_data *data = tester_get_data();
6893         struct mgmt_cp_add_advertising *cp;
6894         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
6895         unsigned char param[] = { 0x01 };
6896
6897         tester_print("Adding two instances with timeout 1 and duration 1");
6898
6899         cp = (struct mgmt_cp_add_advertising *) adv_param;
6900         setup_add_adv_param(cp, 1);
6901         cp->timeout = 1;
6902         cp->duration = 1;
6903
6904         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6905                                                 sizeof(param), &param,
6906                                                 NULL, NULL, NULL);
6907
6908         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6909                                                 sizeof(param), &param,
6910                                                 NULL, NULL, NULL);
6911
6912         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
6913                                                 sizeof(adv_param), adv_param,
6914                                                 setup_multi_adv_second_instance,
6915                                                 NULL, NULL);
6916 }
6917
6918 static void setup_complete(uint8_t status, uint16_t length,
6919                                         const void *param, void *user_data)
6920 {
6921         struct test_data *data = tester_get_data();
6922
6923         if (status != MGMT_STATUS_SUCCESS) {
6924                 tester_setup_failed();
6925                 return;
6926         }
6927
6928         tester_print("Initial settings completed");
6929
6930         if (data->test_setup)
6931                 data->test_setup(data);
6932         else
6933                 setup_bthost();
6934 }
6935
6936 static void setup_set_unpowered_callback(uint8_t status, uint16_t length,
6937                                         const void *param, void *user_data)
6938 {
6939         if (status != MGMT_STATUS_SUCCESS) {
6940                 tester_setup_failed();
6941                 return;
6942         }
6943
6944         setup_bthost();
6945 }
6946
6947 static void setup_set_le_callback(uint8_t status, uint16_t length,
6948                                         const void *param, void *user_data)
6949 {
6950         struct test_data *data = tester_get_data();
6951         unsigned char power_param[] = { 0x00 };
6952
6953         if (status != MGMT_STATUS_SUCCESS) {
6954                 tester_setup_failed();
6955                 return;
6956         }
6957
6958         tester_print("Disabling power");
6959
6960         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
6961                                                 sizeof(power_param),
6962                                                 &power_param,
6963                                                 setup_set_unpowered_callback,
6964                                                 NULL, NULL);
6965 }
6966
6967 static void setup_ext_adv_not_powered(const void *test_data)
6968 {
6969         struct test_data *data = tester_get_data();
6970         unsigned char param[] = { 0x01 };
6971
6972         tester_print("Enabling LE");
6973
6974         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
6975                                                 sizeof(param), &param,
6976                                                 setup_set_le_callback,
6977                                                 NULL, NULL);
6978 }
6979
6980 static void setup_set_ext_adv_params_callback(uint8_t status, uint16_t length,
6981                                         const void *param, void *user_data)
6982 {
6983         if (status != MGMT_STATUS_SUCCESS) {
6984                 tester_setup_failed();
6985                 return;
6986         }
6987
6988         setup_bthost();
6989 }
6990
6991 static void setup_ext_adv_params(const void *test_data)
6992 {
6993         struct test_data *data = tester_get_data();
6994
6995         tester_print("Setting Extended Adv Params");
6996
6997         mgmt_send(data->mgmt, MGMT_OP_ADD_EXT_ADV_PARAMS, data->mgmt_index,
6998                                         sizeof(ext_adv_params_valid),
6999                                         &ext_adv_params_valid,
7000                                         setup_set_ext_adv_params_callback,
7001                                         NULL, NULL);
7002 }
7003
7004 static void pin_code_request_callback(uint16_t index, uint16_t length,
7005                                         const void *param, void *user_data)
7006 {
7007         const struct mgmt_ev_pin_code_request *ev = param;
7008         struct test_data *data = user_data;
7009         const struct generic_data *test = data->test_data;
7010         struct mgmt_cp_pin_code_reply cp;
7011
7012         test_condition_complete(data);
7013
7014         memset(&cp, 0, sizeof(cp));
7015         memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
7016
7017         if (!test->pin) {
7018                 mgmt_reply(data->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
7019                                 data->mgmt_index, sizeof(cp.addr), &cp.addr,
7020                                 NULL, NULL, NULL);
7021                 return;
7022         }
7023
7024         cp.pin_len = test->pin_len;
7025         memcpy(cp.pin_code, test->pin, test->pin_len);
7026
7027         mgmt_reply(data->mgmt, MGMT_OP_PIN_CODE_REPLY, data->mgmt_index,
7028                         sizeof(cp), &cp, NULL, NULL, NULL);
7029 }
7030
7031 static void user_confirm_request_callback(uint16_t index, uint16_t length,
7032                                                         const void *param,
7033                                                         void *user_data)
7034 {
7035         const struct mgmt_ev_user_confirm_request *ev = param;
7036         struct test_data *data = user_data;
7037         const struct generic_data *test = data->test_data;
7038         struct mgmt_cp_user_confirm_reply cp;
7039         uint16_t opcode;
7040
7041         memset(&cp, 0, sizeof(cp));
7042         memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
7043
7044         if (test->reject_confirm)
7045                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
7046         else
7047                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
7048
7049         mgmt_reply(data->mgmt, opcode, data->mgmt_index, sizeof(cp), &cp,
7050                                                         NULL, NULL, NULL);
7051 }
7052
7053 static void user_passkey_request_callback(uint16_t index, uint16_t length,
7054                                                         const void *param,
7055                                                         void *user_data)
7056 {
7057         const struct mgmt_ev_user_passkey_request *ev = param;
7058         struct test_data *data = user_data;
7059         const struct generic_data *test = data->test_data;
7060         struct mgmt_cp_user_passkey_reply cp;
7061
7062         if (test->just_works) {
7063                 tester_warn("User Passkey Request for just-works case");
7064                 tester_test_failed();
7065                 return;
7066         }
7067
7068         memset(&cp, 0, sizeof(cp));
7069         memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
7070
7071         if (test->reject_confirm) {
7072                 mgmt_reply(data->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
7073                                 data->mgmt_index, sizeof(cp.addr), &cp.addr,
7074                                 NULL, NULL, NULL);
7075                 return;
7076         }
7077
7078         mgmt_reply(data->mgmt, MGMT_OP_USER_PASSKEY_REPLY, data->mgmt_index,
7079                                         sizeof(cp), &cp, NULL, NULL, NULL);
7080 }
7081
7082 static void test_setup(const void *test_data)
7083 {
7084         struct test_data *data = tester_get_data();
7085         const struct generic_data *test = data->test_data;
7086         struct bthost *bthost = hciemu_client_get_host(data->hciemu);
7087         const uint16_t *cmd;
7088
7089         if (!test)
7090                 goto proceed;
7091
7092         if (test->pin || test->expect_pin) {
7093                 mgmt_register(data->mgmt, MGMT_EV_PIN_CODE_REQUEST,
7094                                 data->mgmt_index, pin_code_request_callback,
7095                                 data, NULL);
7096                 test_add_condition(data);
7097         }
7098
7099         mgmt_register(data->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
7100                         data->mgmt_index, user_confirm_request_callback,
7101                         data, NULL);
7102
7103         mgmt_register(data->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
7104                         data->mgmt_index, user_passkey_request_callback,
7105                         data, NULL);
7106
7107         if (test->client_pin)
7108                 bthost_set_pin_code(bthost, test->client_pin,
7109                                                         test->client_pin_len);
7110
7111         if (test->client_io_cap)
7112                 bthost_set_io_capability(bthost, test->client_io_cap);
7113
7114         if (test->client_auth_req)
7115                 bthost_set_auth_req(bthost, test->client_auth_req);
7116         else if (!test->just_works)
7117                 bthost_set_auth_req(bthost, 0x01);
7118
7119         if (test->client_reject_confirm)
7120                 bthost_set_reject_user_confirm(bthost, true);
7121
7122         if (test->client_enable_le)
7123                 bthost_write_le_host_supported(bthost, 0x01);
7124
7125         if (test->client_enable_sc)
7126                 bthost_set_sc_support(bthost, 0x01);
7127
7128 proceed:
7129         if (!test || !test->setup_settings) {
7130                 if (data->test_setup)
7131                         data->test_setup(data);
7132                 else
7133                         tester_setup_complete();
7134                 return;
7135         }
7136
7137         for (cmd = test->setup_settings; *cmd; cmd++) {
7138                 unsigned char simple_param[] = { 0x01 };
7139                 unsigned char discov_param[] = { 0x01, 0x00, 0x00 };
7140                 unsigned char privacy_param[] = { 0x01,
7141                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
7142                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
7143                 unsigned char set_exp_feat_param[17] = { 0x00 };
7144                 unsigned char *param = simple_param;
7145                 size_t param_size = sizeof(simple_param);
7146                 mgmt_request_func_t func = NULL;
7147
7148                 /* If this is the last command (next one is 0) request
7149                  * for a callback. */
7150                 if (!cmd[1])
7151                         func = setup_complete;
7152
7153                 if (*cmd == MGMT_OP_SET_DISCOVERABLE) {
7154                         if (test->setup_limited_discov) {
7155                                 discov_param[0] = 0x02;
7156                                 discov_param[1] = 0x01;
7157                         }
7158                         param_size = sizeof(discov_param);
7159                         param = discov_param;
7160                 }
7161
7162                 if (*cmd == MGMT_OP_SET_PRIVACY) {
7163                         param_size = sizeof(privacy_param);
7164                         param = privacy_param;
7165                 }
7166
7167                 if (*cmd == MGMT_OP_START_DISCOVERY) {
7168                         if (test->setup_discovery_param)
7169                                 memcpy(param, test->setup_discovery_param, 1);
7170                 }
7171
7172                 if (*cmd == MGMT_OP_SET_EXP_FEATURE) {
7173                         if (test->setup_exp_feat_param) {
7174                                 memcpy(set_exp_feat_param,
7175                                        test->setup_exp_feat_param, 17);
7176                                 param_size = sizeof(set_exp_feat_param);
7177                                 param = set_exp_feat_param;
7178                         }
7179                 }
7180
7181                 if (*cmd == MGMT_OP_SET_LE && test->setup_nobredr) {
7182                         unsigned char off[] = { 0x00 };
7183                         tester_print("Setup sending %s (0x%04x)",
7184                                                         mgmt_opstr(*cmd), *cmd);
7185                         mgmt_send(data->mgmt, *cmd, data->mgmt_index,
7186                                         param_size, param, NULL, NULL, NULL);
7187                         tester_print("Setup sending %s (0x%04x)",
7188                                         mgmt_opstr(MGMT_OP_SET_BREDR),
7189                                         MGMT_OP_SET_BREDR);
7190                         mgmt_send(data->mgmt, MGMT_OP_SET_BREDR,
7191                                         data->mgmt_index, sizeof(off), off,
7192                                         func, data, NULL);
7193                 } else {
7194                         tester_print("Setup sending %s (0x%04x)",
7195                                                         mgmt_opstr(*cmd), *cmd);
7196                         mgmt_send(data->mgmt, *cmd, data->mgmt_index,
7197                                         param_size, param, func, data, NULL);
7198                 }
7199         }
7200 }
7201
7202 static void command_generic_new_settings(uint16_t index, uint16_t length,
7203                                         const void *param, void *user_data)
7204 {
7205         struct test_data *data = tester_get_data();
7206
7207         tester_print("New settings event received");
7208
7209         mgmt_unregister(data->mgmt, data->mgmt_settings_id);
7210
7211         tester_test_failed();
7212 }
7213
7214 static void command_generic_new_settings_alt(uint16_t index, uint16_t length,
7215                                         const void *param, void *user_data)
7216 {
7217         struct test_data *data = tester_get_data();
7218         const struct generic_data *test = data->test_data;
7219         uint32_t settings;
7220
7221         if (length != 4) {
7222                 tester_warn("Invalid parameter size for new settings event");
7223                 tester_test_failed();
7224                 return;
7225         }
7226
7227         settings = get_le32(param);
7228
7229         tester_print("New settings 0x%08x received", settings);
7230
7231         if (test->expect_settings_unset) {
7232                 if ((settings & test->expect_settings_unset) != 0)
7233                         return;
7234                 goto done;
7235         }
7236
7237         if (!test->expect_settings_set)
7238                 return;
7239
7240         if ((settings & test->expect_settings_set) != test->expect_settings_set)
7241                 return;
7242
7243 done:
7244         tester_print("Unregistering new settings notification");
7245
7246         mgmt_unregister(data->mgmt_alt, data->mgmt_alt_settings_id);
7247
7248         test_condition_complete(data);
7249 }
7250
7251 static bool verify_alt_ev(const void *param, uint16_t length)
7252 {
7253         struct test_data *data = tester_get_data();
7254         const struct generic_data *test = data->test_data;
7255
7256         if (length != test->expect_alt_ev_len) {
7257                 tester_warn("Invalid length %u != %u", length,
7258                                                 test->expect_alt_ev_len);
7259                 return false;
7260         }
7261
7262         if (test->expect_alt_ev_param &&
7263                         memcmp(test->expect_alt_ev_param, param, length)) {
7264                 tester_warn("Event parameters do not match");
7265                 util_hexdump('>', param, length, print_debug, "");
7266                 util_hexdump('!', test->expect_alt_ev_param, length,
7267                                                         print_debug, "");
7268                 return false;
7269         }
7270
7271         return true;
7272 }
7273
7274 static void command_generic_event_alt(uint16_t index, uint16_t length,
7275                                                         const void *param,
7276                                                         void *user_data)
7277 {
7278         struct test_data *data = tester_get_data();
7279         const struct generic_data *test = data->test_data;
7280         bool (*verify)(const void *param, uint16_t length);
7281
7282         tester_print("New %s event received", mgmt_evstr(test->expect_alt_ev));
7283
7284         mgmt_unregister(data->mgmt_alt, data->mgmt_alt_ev_id);
7285
7286         if (test->verify_alt_ev_func)
7287                 verify = test->verify_alt_ev_func;
7288         else
7289                 verify = verify_alt_ev;
7290
7291         if (!verify(param, length)) {
7292                 tester_warn("Incorrect %s event parameters",
7293                                         mgmt_evstr(test->expect_alt_ev));
7294                 tester_test_failed();
7295                 return;
7296         }
7297
7298         test_condition_complete(data);
7299 }
7300
7301 static void command_generic_callback(uint8_t status, uint16_t length,
7302                                         const void *param, void *user_data)
7303 {
7304         struct test_data *data = tester_get_data();
7305         const struct generic_data *test = data->test_data;
7306         const void *expect_param = test->expect_param;
7307         uint16_t expect_len = test->expect_len;
7308
7309         tester_print("%s (0x%04x): %s (0x%02x)", mgmt_opstr(test->send_opcode),
7310                         test->send_opcode, mgmt_errstr(status), status);
7311
7312         if (status != test->expect_status) {
7313                 if (!test->fail_tolerant || !!status != !!test->expect_status) {
7314                         tester_test_abort();
7315                         return;
7316                 }
7317
7318                 tester_warn("Unexpected status got %d expected %d",
7319                                                 status, test->expect_status);
7320         }
7321
7322         if (!test->expect_ignore_param) {
7323                 if (test->expect_func)
7324                         expect_param = test->expect_func(&expect_len);
7325
7326                 if (length != expect_len) {
7327                         tester_warn("Invalid cmd response parameter size");
7328                         tester_test_failed();
7329                         return;
7330                 }
7331
7332                 if (expect_param && expect_len > 0 &&
7333                                         memcmp(param, expect_param, length)) {
7334                         tester_warn("Unexpected cmd response parameter value");
7335                         util_hexdump('>', param, length, print_debug, "");
7336                         util_hexdump('!', expect_param, length, print_debug,
7337                                                                 "");
7338                         tester_test_failed();
7339                         return;
7340                 }
7341         }
7342
7343         test_condition_complete(data);
7344 }
7345
7346 static void command_setup_hci_callback(uint16_t opcode, const void *param,
7347                                         uint8_t length, void *user_data)
7348 {
7349         struct test_data *data = user_data;
7350         const struct generic_data *test = data->test_data;
7351         const void *setup_expect_hci_param = test->setup_expect_hci_param;
7352         uint8_t setup_expect_hci_len = test->setup_expect_hci_len;
7353
7354         tester_print("HCI Command 0x%04x length %u", opcode, length);
7355
7356         if (opcode != test->setup_expect_hci_command)
7357                 return;
7358
7359         if (length != setup_expect_hci_len) {
7360                 tester_warn("Invalid parameter size for HCI command");
7361                 tester_test_failed();
7362                 return;
7363         }
7364
7365         if (memcmp(param, setup_expect_hci_param, length) != 0) {
7366                 tester_warn("Unexpected HCI command parameter value");
7367                 tester_test_failed();
7368                 return;
7369         }
7370
7371         hciemu_clear_central_post_command_hooks(data->hciemu);
7372         test_setup_condition_complete(data);
7373 }
7374
7375 static void command_hci_callback(uint16_t opcode, const void *param,
7376                                         uint8_t length, void *user_data)
7377 {
7378         struct test_data *data = user_data;
7379         const struct generic_data *test = data->test_data;
7380         const void *expect_hci_param = test->expect_hci_param;
7381         uint8_t expect_hci_len = test->expect_hci_len;
7382         int ret;
7383
7384         tester_print("HCI Command 0x%04x length %u", opcode, length);
7385
7386         if (opcode != test->expect_hci_command || data->expect_hci_command_done)
7387                 return;
7388
7389         data->expect_hci_command_done = true;
7390
7391         if (test->expect_hci_func)
7392                 expect_hci_param = test->expect_hci_func(&expect_hci_len);
7393
7394         if (length != expect_hci_len) {
7395                 tester_warn("Invalid parameter size for HCI command");
7396                 tester_test_failed();
7397                 return;
7398         }
7399
7400         if (test->expect_hci_param_check_func)
7401                 ret = test->expect_hci_param_check_func(param, length);
7402         else
7403                 ret = memcmp(param, expect_hci_param, length);
7404         if (ret != 0) {
7405                 tester_warn("Unexpected HCI command parameter value:");
7406                 util_hexdump('>', param, length, print_debug, "");
7407                 util_hexdump('!', expect_hci_param, length, print_debug, "");
7408                 tester_test_failed();
7409                 return;
7410         }
7411
7412         test_condition_complete(data);
7413 }
7414
7415 static bool match_hci_cmd_opcode(const void *data, const void *match_data)
7416 {
7417         const struct hci_entry *entry = data;
7418         uint16_t opcode = PTR_TO_UINT(match_data);
7419
7420         return entry->cmd_data->opcode == opcode;
7421 }
7422
7423 static void command_hci_list_callback(uint16_t opcode, const void *param,
7424                                         uint8_t length, void *user_data)
7425 {
7426         struct test_data *data = user_data;
7427         const struct hci_cmd_data *hci_cmd_data;
7428         struct hci_entry *entry;
7429         int ret;
7430
7431         tester_print("HCI Command 0x%04x length %u", opcode, length);
7432
7433         entry = queue_find(data->expect_hci_q, match_hci_cmd_opcode,
7434                                                         UINT_TO_PTR(opcode));
7435         if (!entry)
7436                 return;
7437
7438         /* Save the hci cmd data before removing the queue entry */
7439         hci_cmd_data = entry->cmd_data;
7440
7441         /* Remove the entry from the queue and free the entry */
7442         queue_remove(data->expect_hci_q, entry);
7443         free(entry);
7444
7445         if (length != hci_cmd_data->len) {
7446                 tester_warn("Invalid parameter size for HCI command");
7447                 tester_test_failed();
7448                 return;
7449         }
7450
7451         ret = memcmp(param, hci_cmd_data->param, length);
7452         if (ret != 0) {
7453                 tester_warn("Unexpected HCI command parameter value:");
7454                 util_hexdump('>', param, length, print_debug, "");
7455                 util_hexdump('!', hci_cmd_data->param, length, print_debug, "");
7456                 tester_test_failed();
7457                 return;
7458         }
7459
7460         test_condition_complete(data);
7461 }
7462
7463 static void setup_mgmt_cmd_callback(uint8_t status, uint16_t length,
7464                                         const void *param, void *user_data)
7465 {
7466         if (status != MGMT_STATUS_SUCCESS) {
7467                 tester_setup_failed();
7468                 return;
7469         }
7470         test_setup_condition_complete(user_data);
7471 }
7472
7473 static void setup_command_generic(const void *test_data)
7474 {
7475         struct test_data *data = tester_get_data();
7476         const struct generic_data *test = data->test_data;
7477         const void *send_param = test->setup_send_param;
7478         uint16_t send_len = test->setup_send_len;
7479         size_t i = 0;
7480
7481         if (test->setup_expect_hci_command) {
7482                 tester_print("Registering setup expected HCI command callback");
7483                 tester_print("Setup expected HCI command 0x%04x",
7484                                          test->setup_expect_hci_command);
7485                 hciemu_add_central_post_command_hook(data->hciemu,
7486                                         command_setup_hci_callback, data);
7487                 test_add_setup_condition(data);
7488         }
7489
7490         if (test->setup_send_opcode) {
7491                 tester_print("Setup sending %s (0x%04x)",
7492                                 mgmt_opstr(test->setup_send_opcode),
7493                                 test->setup_send_opcode);
7494                 mgmt_send(data->mgmt, test->setup_send_opcode, data->mgmt_index,
7495                                         send_len, send_param,
7496                                         setup_mgmt_cmd_callback,
7497                                         data, NULL);
7498                 test_add_setup_condition(data);
7499                 return;
7500         }
7501
7502         tester_print("Sending setup opcode array");
7503         for (; test->setup_mgmt_cmd_arr + i; ++i) {
7504                 const struct setup_mgmt_cmd *cmd = test->setup_mgmt_cmd_arr + i;
7505
7506                 if (cmd->send_opcode == 0x00)
7507                         break;
7508
7509                 tester_print("Setup sending %s (0x%04x)",
7510                                 mgmt_opstr(cmd->send_opcode),
7511                                 cmd->send_opcode);
7512
7513                 mgmt_send(data->mgmt, cmd->send_opcode, data->mgmt_index,
7514                                 cmd->send_len, cmd->send_param,
7515                                 setup_mgmt_cmd_callback,
7516                                 data, NULL);
7517                 test_add_setup_condition(data);
7518         }
7519 }
7520
7521 static const uint8_t add_advertising_param_empty[] = {
7522         0x01,                   /* adv instance */
7523         0x00, 0x00, 0x00, 0x00, /* flags: none */
7524         0x00, 0x00,             /* duration: default */
7525         0x00, 0x00,             /* timeout: none */
7526         0x00,                   /* adv data len */
7527         0x00,                   /* scan rsp len */
7528 };
7529
7530 static const struct generic_data add_advertising_empty_scrsp = {
7531         .setup_settings = settings_powered_le,
7532         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
7533         .setup_send_param = set_local_name_param,
7534         .setup_send_len = sizeof(set_local_name_param),
7535         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7536         .send_param = add_advertising_param_empty,
7537         .send_len = sizeof(add_advertising_param_empty),
7538         .expect_status = MGMT_STATUS_SUCCESS,
7539         .expect_param = advertising_instance1_param,
7540         .expect_len = sizeof(advertising_instance1_param),
7541 };
7542
7543 static const uint8_t add_advertising_param_scrsp_data_only_ok[] = {
7544         0x01,                   /* adv instance */
7545         0x00, 0x00, 0x00, 0x00, /* flags: none */
7546         0x00, 0x00,             /* duration: default */
7547         0x00, 0x00,             /* timeout: none */
7548         0x00,                   /* adv data len */
7549         0x1f,                   /* scan rsp len */
7550         /* adv data: */
7551         /* scan rsp data: */
7552         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7553         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7554         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7555         0x00,
7556 };
7557
7558 static const struct generic_data add_advertising_scrsp_data_only_ok = {
7559         .setup_settings = settings_powered_le,
7560         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7561         .send_param = add_advertising_param_scrsp_data_only_ok,
7562         .send_len = sizeof(add_advertising_param_scrsp_data_only_ok),
7563         .expect_status = MGMT_STATUS_SUCCESS,
7564         .expect_param = advertising_instance1_param,
7565         .expect_len = sizeof(advertising_instance1_param),
7566 };
7567
7568 static const uint8_t add_advertising_param_scrsp_data_only_too_long[] = {
7569         0x01,                   /* adv instance */
7570         0x00, 0x00, 0x00, 0x00, /* flags: none */
7571         0x00, 0x00,             /* duration: default */
7572         0x00, 0x00,             /* timeout: none */
7573         0x00,                   /* adv data len */
7574         0x20,                   /* scan rsp len */
7575         /* adv data: */
7576         /* scan rsp data: */
7577         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7578         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7579         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7580         0x00, 0x00,
7581 };
7582
7583 static const struct generic_data add_advertising_scrsp_data_only_too_long = {
7584         .setup_settings = settings_powered_le,
7585         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7586         .send_param = add_advertising_param_scrsp_data_only_too_long,
7587         .send_len = sizeof(add_advertising_param_scrsp_data_only_too_long),
7588         .expect_status = MGMT_STATUS_INVALID_PARAMS,
7589         .expect_param = NULL,
7590         .expect_len = 0,
7591 };
7592
7593 static const uint8_t set_appearance_param[2] = { 0x54, 0x65 };
7594
7595 static const uint8_t add_advertising_param_scrsp_appear_data_ok[] = {
7596         0x01,                   /* adv instance */
7597         0x20, 0x00, 0x00, 0x00, /* flags: appearance */
7598         0x00, 0x00,             /* duration: default */
7599         0x00, 0x00,             /* timeout: none */
7600         0x00,                   /* adv data len */
7601         0x1b,                   /* scan rsp len */
7602         /* adv data: */
7603         /* scan rsp data: */
7604         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7605         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7606         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7607 };
7608
7609 static const struct generic_data add_advertising_scrsp_appear_data_ok = {
7610         .setup_settings = settings_powered_le,
7611         .setup_send_opcode = MGMT_OP_SET_APPEARANCE,
7612         .setup_send_param = set_appearance_param,
7613         .setup_send_len = sizeof(set_appearance_param),
7614         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7615         .send_param = add_advertising_param_scrsp_appear_data_ok,
7616         .send_len = sizeof(add_advertising_param_scrsp_appear_data_ok),
7617         .expect_status = MGMT_STATUS_SUCCESS,
7618         .expect_param = advertising_instance1_param,
7619         .expect_len = sizeof(advertising_instance1_param),
7620 };
7621
7622 static const uint8_t add_advertising_param_scrsp_appear_data_too_long[] = {
7623         0x01,                   /* adv instance */
7624         0x20, 0x00, 0x00, 0x00, /* flags: appearance */
7625         0x00, 0x00,             /* duration: default */
7626         0x00, 0x00,             /* timeout: none */
7627         0x00,                   /* adv data len */
7628         0x1c,                   /* scan rsp len */
7629         /* adv data: */
7630         /* scan rsp data: */
7631         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7632         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7633         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7634 };
7635
7636 static const struct generic_data add_advertising_scrsp_appear_data_too_long = {
7637         .setup_settings = settings_powered_le,
7638         .setup_send_opcode = MGMT_OP_SET_APPEARANCE,
7639         .setup_send_param = set_appearance_param,
7640         .setup_send_len = sizeof(set_appearance_param),
7641         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7642         .send_param = add_advertising_param_scrsp_appear_data_too_long,
7643         .send_len = sizeof(add_advertising_param_scrsp_appear_data_too_long),
7644         .expect_status = MGMT_STATUS_INVALID_PARAMS,
7645         .expect_param = NULL,
7646         .expect_len = 0,
7647 };
7648
7649 static const uint8_t add_advertising_param_scrsp_appear_null[] = {
7650         0x01,                   /* adv instance */
7651         0x20, 0x00, 0x00, 0x00, /* flags: appearance */
7652         0x00, 0x00,             /* duration: default */
7653         0x00, 0x00,             /* timeout: none */
7654         0x00,                   /* adv data len */
7655         0x01,                   /* scan rsp len */
7656         /* adv data: */
7657         /* scan rsp data: */
7658         0x00,
7659 };
7660
7661 static const struct generic_data add_advertising_scrsp_appear_null = {
7662         .setup_settings = settings_powered_le,
7663         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7664         .send_param = add_advertising_param_scrsp_appear_null,
7665         .send_len = sizeof(add_advertising_param_scrsp_appear_null),
7666         .expect_status = MGMT_STATUS_SUCCESS,
7667         .expect_param = advertising_instance1_param,
7668         .expect_len = sizeof(advertising_instance1_param),
7669 };
7670
7671 static const uint8_t add_advertising_empty_param[] = {
7672         0x01,                   /* adv instance */
7673         0x40, 0x00, 0x00, 0x00, /* flags: local name*/
7674         0x00, 0x00,             /* duration: default */
7675         0x00, 0x00,             /* timeout: none */
7676         0x00,                   /* adv data len */
7677         0x01,                   /* scan rsp len */
7678         /* scan rsp data: */
7679         0x00,
7680 };
7681
7682 static const uint8_t scan_rsp_data_empty[] = {
7683         0x01, /* scan rsp data len */
7684         0x00, /* scan rsp data */
7685         /* placeholder data */
7686         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7687         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7688         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7689 };
7690
7691 static const struct generic_data add_advertising_no_name_set = {
7692         .setup_settings = settings_powered_le,
7693         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7694         .send_param = add_advertising_empty_param,
7695         .send_len = sizeof(add_advertising_empty_param),
7696         .expect_status = MGMT_STATUS_SUCCESS,
7697         .expect_param = advertising_instance1_param,
7698         .expect_len = sizeof(advertising_instance1_param),
7699         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
7700         .expect_hci_param = scan_rsp_data_empty,
7701         .expect_hci_len = sizeof(scan_rsp_data_empty),
7702 };
7703
7704 static const uint8_t add_advertising_param_name[] = {
7705         0x01,                   /* adv instance */
7706         0x40, 0x00, 0x00, 0x00, /* flags: Add local name to scan_rsp */
7707         0x00, 0x00,             /* duration: default */
7708         0x00, 0x00,             /* timeout: none */
7709         0x00,                   /* adv data len */
7710         0x00,                   /* scan rsp len */
7711 };
7712
7713 static const uint8_t set_scan_rsp_data_name_fits_in_scrsp[] = {
7714         0x0c, /* Scan rsp data len */
7715         0x0b, /* Local name data len */
7716         0x09, /* Complete name */
7717         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, /* "Test name" */
7718         /* padding */
7719         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7720         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7721 };
7722
7723 static const struct generic_data add_advertising_name_fits_in_scrsp = {
7724         .setup_settings = settings_powered_le,
7725         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
7726         .setup_send_param = &set_local_name_cp,
7727         .setup_send_len = sizeof(set_local_name_cp),
7728         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7729         .send_param = add_advertising_param_name,
7730         .send_len = sizeof(add_advertising_param_name),
7731         .expect_status = MGMT_STATUS_SUCCESS,
7732         .expect_param = advertising_instance1_param,
7733         .expect_len = sizeof(advertising_instance1_param),
7734         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
7735         .expect_hci_param = set_scan_rsp_data_name_fits_in_scrsp,
7736         .expect_hci_len = sizeof(set_scan_rsp_data_name_fits_in_scrsp),
7737 };
7738
7739 static const uint8_t set_scan_rsp_data_shortened_name_fits[] = {
7740         0x0d, /* Scan rsp data len */
7741         0x0c, /* Local name data len */
7742         0x08, /* Short name */
7743         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x31,
7744         /* "Test name1" */
7745         /* padding */
7746         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7747         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7748 };
7749
7750 static const struct generic_data add_advertising_shortened_name_in_scrsp = {
7751         .setup_settings = settings_powered_le,
7752         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
7753         .setup_send_param = &set_local_name_longer_cp,
7754         .setup_send_len = sizeof(set_local_name_longer_cp),
7755         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7756         .send_param = add_advertising_param_name,
7757         .send_len = sizeof(add_advertising_param_name),
7758         .expect_status = MGMT_STATUS_SUCCESS,
7759         .expect_param = advertising_instance1_param,
7760         .expect_len = sizeof(advertising_instance1_param),
7761         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
7762         .expect_hci_param = set_scan_rsp_data_shortened_name_fits,
7763         .expect_hci_len = sizeof(set_scan_rsp_data_shortened_name_fits),
7764 };
7765
7766 static const uint8_t set_scan_rsp_data_short_name_fits[] = {
7767         0x07, /* Scan rsp data len */
7768         0x06, /* Local name data len */
7769         0x08, /* Short name */
7770         0x54, 0x65, 0x73, 0x74,
7771         /* "Test*/
7772         /* padding */
7773         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7774         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7775         0x00, 0x00, 0x00, 0x00, 0x00,
7776 };
7777
7778 static const struct generic_data add_advertising_short_name_in_scrsp = {
7779         .setup_settings = settings_powered_le,
7780         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
7781         .setup_send_param = &set_local_name_long_short_cp,
7782         .setup_send_len = sizeof(set_local_name_long_short_cp),
7783         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7784         .send_param = add_advertising_param_name,
7785         .send_len = sizeof(add_advertising_param_name),
7786         .expect_status = MGMT_STATUS_SUCCESS,
7787         .expect_param = advertising_instance1_param,
7788         .expect_len = sizeof(advertising_instance1_param),
7789         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
7790         .expect_hci_param = set_scan_rsp_data_short_name_fits,
7791         .expect_hci_len = sizeof(set_scan_rsp_data_short_name_fits),
7792 };
7793
7794 static const uint8_t add_advertising_param_name_data_ok[] = {
7795         0x01,                   /* adv instance */
7796         0x40, 0x00, 0x00, 0x00, /* flags: local name */
7797         0x00, 0x00,             /* duration: default */
7798         0x00, 0x00,             /* timeout: none */
7799         0x00,                   /* adv data len */
7800         0x12,                   /* scan rsp len */
7801         /* adv data: */
7802         /* scan rsp data: */
7803         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7804         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7805 };
7806
7807 static const uint8_t set_scan_rsp_data_param_name_data_ok[] = {
7808         0x1e, /* Scan rsp data len */
7809         /* scan rsp data */
7810         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7811         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7812         0x0b, /* Local name data len */
7813         0x09, /* Complete name */
7814         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x00,
7815         /* "Test name" */
7816         /* padding */
7817         0x00,
7818 };
7819
7820 static const struct generic_data add_advertising_name_data_ok = {
7821         .setup_settings = settings_powered_le,
7822         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
7823         .setup_send_param = &set_local_name_cp,
7824         .setup_send_len = sizeof(set_local_name_cp),
7825         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7826         .send_param = add_advertising_param_name_data_ok,
7827         .send_len = sizeof(add_advertising_param_name_data_ok),
7828         .expect_status = MGMT_STATUS_SUCCESS,
7829         .expect_param = advertising_instance1_param,
7830         .expect_len = sizeof(advertising_instance1_param),
7831         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
7832         .expect_hci_param = set_scan_rsp_data_param_name_data_ok,
7833         .expect_hci_len = sizeof(set_scan_rsp_data_param_name_data_ok),
7834 };
7835
7836 static const uint8_t add_advertising_param_name_data_inv[] = {
7837         0x01,                   /* adv instance */
7838         0x40, 0x00, 0x00, 0x00, /* flags: local name */
7839         0x00, 0x00,             /* duration: default */
7840         0x00, 0x00,             /* timeout: none */
7841         0x00,                   /* adv data len */
7842         0x14,                   /* scan rsp len */
7843         /* adv data: */
7844         /* scan rsp data: */
7845         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7846         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
7847 };
7848
7849 static const struct generic_data add_advertising_name_data_inv = {
7850         .setup_settings = settings_powered_le,
7851         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
7852         .setup_send_param = &set_local_name_cp,
7853         .setup_send_len = sizeof(set_local_name_cp),
7854         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7855         .send_param = add_advertising_param_name_data_inv,
7856         .send_len = sizeof(add_advertising_param_name_data_inv),
7857         .expect_status = MGMT_STATUS_INVALID_PARAMS,
7858         .expect_param = NULL,
7859         .expect_len = 0,
7860 };
7861
7862 static const uint8_t add_advertising_param_name_data_appear[] = {
7863         0x01,                   /* adv instance */
7864         0x60, 0x00, 0x00, 0x00, /* flags: local name + appearance */
7865         0x00, 0x00,             /* duration: default */
7866         0x00, 0x00,             /* timeout: none */
7867         0x00,                   /* adv data len */
7868         0x0e,                   /* scan rsp len */
7869         /* adv data: */
7870         /* scan rsp data: */
7871         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7872         0x00, 0x00, 0x00, 0x00,
7873 };
7874
7875 static const struct setup_mgmt_cmd add_advertising_mgmt_cmd_arr[] = {
7876         {
7877                 .send_opcode = MGMT_OP_SET_APPEARANCE,
7878                 .send_param = set_appearance_param,
7879                 .send_len = sizeof(set_appearance_param),
7880         },
7881         {
7882                 .send_opcode = MGMT_OP_SET_LOCAL_NAME,
7883                 .send_param = &set_local_name_cp,
7884                 .send_len = sizeof(set_local_name_cp),
7885         },
7886         { /* last element should always have opcode 0x00 */
7887                 .send_opcode = 0x00,
7888                 .send_param = NULL,
7889                 .send_len = 0,
7890         }
7891 };
7892
7893 static const uint8_t set_scan_rsp_data_name_data_appear[] = {
7894         0x1e, /* Scan rsp data len */
7895         0x03, /* appearance len */
7896         0x19, /* EIR_APPEARANCE */
7897         0x54, 0x65, /* appearance value */
7898         /* scan rsp data */
7899         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
7900         0x00, 0x00, 0x00, 0x00,
7901         0x0b, /* Local name data len */
7902         0x09, /* Complete name */
7903         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x00,
7904         /* "Test name" */
7905         /* padding */
7906         0x00,
7907 };
7908
7909 static const struct generic_data add_advertising_name_data_appear = {
7910         .setup_settings = settings_powered_le,
7911         .setup_mgmt_cmd_arr = add_advertising_mgmt_cmd_arr,
7912         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7913         .send_param = add_advertising_param_name_data_appear,
7914         .send_len = sizeof(add_advertising_param_name_data_appear),
7915         .expect_status = MGMT_STATUS_SUCCESS,
7916         .expect_param = advertising_instance1_param,
7917         .expect_len = sizeof(advertising_instance1_param),
7918         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
7919         .expect_hci_param = set_scan_rsp_data_name_data_appear,
7920         .expect_hci_len = sizeof(set_scan_rsp_data_name_data_appear),
7921 };
7922
7923 static const struct generic_data set_appearance_not_supported = {
7924         .send_opcode = MGMT_OP_SET_APPEARANCE,
7925         .send_param = set_appearance_param,
7926         .send_len = sizeof(set_appearance_param),
7927         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
7928         .expect_param = NULL,
7929         .expect_len = 0,
7930 };
7931
7932 static const struct generic_data set_appearance_success = {
7933         .send_opcode = MGMT_OP_SET_APPEARANCE,
7934         .send_param = set_appearance_param,
7935         .send_len = sizeof(set_appearance_param),
7936         .expect_status = MGMT_STATUS_SUCCESS,
7937         .expect_param = NULL,
7938         .expect_len = 0,
7939 };
7940
7941 static const uint8_t read_adv_features_rsp_3[] =  {
7942         0xff, 0xff, 0x01, 0x00, /* supported flags */
7943         0x1f,                   /* max_adv_data_len */
7944         0x1f,                   /* max_scan_rsp_len */
7945         0x03,                   /* max_instances */
7946         0x00,                   /* num_instances */
7947 };
7948
7949 static const struct generic_data read_adv_features_success_3 = {
7950         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
7951         .expect_param = read_adv_features_rsp_3,
7952         .expect_len = sizeof(read_adv_features_rsp_3),
7953         .expect_status = MGMT_STATUS_SUCCESS,
7954 };
7955
7956 /* add advertising with multiple phy flags */
7957 static const uint8_t add_ext_advertising_invalid_param_1[] = {
7958         0x01,                   /* adv instance */
7959         0x80, 0x01, 0x00, 0x00, /* flags: 1m and 2m*/
7960         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
7961         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
7962 };
7963
7964 static const struct generic_data add_ext_advertising_fail_1 = {
7965         .setup_settings = settings_powered_le,
7966         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7967         .send_param = add_ext_advertising_invalid_param_1,
7968         .send_len = sizeof(add_ext_advertising_invalid_param_1),
7969         .expect_status = MGMT_STATUS_INVALID_PARAMS,
7970 };
7971
7972 /* add advertising with multiple phy flags */
7973 static const uint8_t add_ext_advertising_invalid_param_2[] = {
7974         0x01,                   /* adv instance */
7975         0x00, 0x03, 0x00, 0x00, /* flags: 2m and coded*/
7976         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
7977         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
7978 };
7979
7980 static const struct generic_data add_ext_advertising_fail_2 = {
7981         .setup_settings = settings_powered_le,
7982         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7983         .send_param = add_ext_advertising_invalid_param_2,
7984         .send_len = sizeof(add_ext_advertising_invalid_param_2),
7985         .expect_status = MGMT_STATUS_INVALID_PARAMS,
7986 };
7987
7988 /* add advertising with multiple phy flags */
7989 static const uint8_t add_ext_advertising_invalid_param_3[] = {
7990         0x01,                   /* adv instance */
7991         0x80, 0x02, 0x00, 0x00, /* flags: 1m and coded*/
7992         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
7993         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
7994 };
7995
7996 static const struct generic_data add_ext_advertising_fail_3 = {
7997         .setup_settings = settings_powered_le,
7998         .send_opcode = MGMT_OP_ADD_ADVERTISING,
7999         .send_param = add_ext_advertising_invalid_param_3,
8000         .send_len = sizeof(add_ext_advertising_invalid_param_3),
8001         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8002 };
8003
8004 /* add advertising with multiple phy flags */
8005 static const uint8_t add_ext_advertising_invalid_param_4[] = {
8006         0x01,                   /* adv instance */
8007         0x80, 0x03, 0x00, 0x00, /* flags: 1m, 2m and coded*/
8008         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
8009         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
8010 };
8011
8012 static const struct generic_data add_ext_advertising_fail_4 = {
8013         .setup_settings = settings_powered_le,
8014         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8015         .send_param = add_ext_advertising_invalid_param_4,
8016         .send_len = sizeof(add_ext_advertising_invalid_param_4),
8017         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8018 };
8019
8020 static const uint8_t set_ext_adv_data_uuid[] = {
8021         /* handle */
8022         0x01,
8023         /* complete data */
8024         0x03,
8025         /* controller should not fragment */
8026         0x01,
8027         /* adv data len */
8028         0x09,
8029         /* advertise heart rate monitor and manufacturer specific data */
8030         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
8031 };
8032
8033 static const struct generic_data add_ext_advertising_success_1 = {
8034         .setup_settings = settings_powered_le,
8035         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8036         .send_param = add_advertising_param_uuid,
8037         .send_len = sizeof(add_advertising_param_uuid),
8038         .expect_param = advertising_instance1_param,
8039         .expect_len = sizeof(advertising_instance1_param),
8040         .expect_status = MGMT_STATUS_SUCCESS,
8041         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
8042         .expect_alt_ev_param = advertising_instance1_param,
8043         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8044         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8045         .expect_hci_param = set_ext_adv_data_uuid,
8046         .expect_hci_len = sizeof(set_ext_adv_data_uuid),
8047 };
8048
8049 static const uint8_t set_ext_adv_data_test1[] = {
8050         0x01,                           /* handle */
8051         0x03,                           /* complete data */
8052         0x01,                           /* controller should not fragment */
8053         0x07,                           /* adv data len */
8054         0x06,                           /* AD len */
8055         0x08,                           /* AD type: shortened local name */
8056         0x74, 0x65, 0x73, 0x74, 0x31,   /* "test1" */
8057 };
8058
8059 static const struct generic_data add_ext_advertising_success_pwron_data = {
8060         .send_opcode = MGMT_OP_SET_POWERED,
8061         .send_param = set_powered_on_param,
8062         .send_len = sizeof(set_powered_on_param),
8063         .expect_status = MGMT_STATUS_SUCCESS,
8064         .expect_param = set_powered_adv_instance_settings_param,
8065         .expect_len = sizeof(set_powered_adv_instance_settings_param),
8066         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8067         .expect_hci_param = set_ext_adv_data_test1,
8068         .expect_hci_len = sizeof(set_ext_adv_data_test1),
8069 };
8070
8071 static const char set_ext_adv_on_set_adv_enable_param[] = {
8072         0x01,           /* Enable */
8073         0x01,           /* No of sets */
8074         0x01,           /* Handle */
8075         0x00, 0x00,             /* Duration */
8076         0x00,           /* Max events */
8077 };
8078
8079 static const struct generic_data add_ext_advertising_success_pwron_enabled = {
8080         .send_opcode = MGMT_OP_SET_POWERED,
8081         .send_param = set_powered_on_param,
8082         .send_len = sizeof(set_powered_on_param),
8083         .expect_status = MGMT_STATUS_SUCCESS,
8084         .expect_param = set_powered_adv_instance_settings_param,
8085         .expect_len = sizeof(set_powered_adv_instance_settings_param),
8086         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
8087         .expect_hci_param = set_ext_adv_on_set_adv_enable_param,
8088         .expect_hci_len = sizeof(set_ext_adv_on_set_adv_enable_param),
8089 };
8090
8091 static const uint8_t set_ext_adv_data_txpwr[] = {
8092         0x00,                           /* handle */
8093         0x03,                           /* complete data */
8094         0x01,                           /* controller should not fragment */
8095         0x03,                   /* adv data len */
8096         0x02,                   /* AD len */
8097         0x0a,                   /* AD type: tx power */
8098         0x00,                   /* tx power */
8099 };
8100
8101 static const struct generic_data add_ext_advertising_success_4 = {
8102         .send_opcode = MGMT_OP_SET_ADVERTISING,
8103         .send_param = set_adv_on_param,
8104         .send_len = sizeof(set_adv_on_param),
8105         .expect_status = MGMT_STATUS_SUCCESS,
8106         .expect_param = set_adv_settings_param_2,
8107         .expect_len = sizeof(set_adv_settings_param_2),
8108         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8109         .expect_hci_param = set_ext_adv_data_txpwr,
8110         .expect_hci_len = sizeof(set_ext_adv_data_txpwr),
8111 };
8112
8113 static const struct generic_data add_ext_advertising_success_5 = {
8114         .send_opcode = MGMT_OP_SET_ADVERTISING,
8115         .send_param = set_adv_off_param,
8116         .send_len = sizeof(set_adv_off_param),
8117         .expect_status = MGMT_STATUS_SUCCESS,
8118         .expect_param = set_powered_adv_instance_settings_param,
8119         .expect_len = sizeof(set_powered_adv_instance_settings_param),
8120         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8121         .expect_hci_param = set_ext_adv_data_test1,
8122         .expect_hci_len = sizeof(set_ext_adv_data_test1),
8123 };
8124
8125 static const struct generic_data add_ext_advertising_success_6 = {
8126         .setup_settings = settings_powered_le,
8127         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8128         .send_param = add_advertising_param_scanrsp,
8129         .send_len = sizeof(add_advertising_param_scanrsp),
8130         .expect_param = advertising_instance1_param,
8131         .expect_len = sizeof(advertising_instance1_param),
8132         .expect_status = MGMT_STATUS_SUCCESS,
8133         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
8134         .expect_alt_ev_param = advertising_instance1_param,
8135         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8136         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8137         .expect_hci_param = set_ext_adv_data_uuid,
8138         .expect_hci_len = sizeof(set_ext_adv_data_uuid),
8139 };
8140
8141 static const uint8_t set_ext_scan_rsp_uuid[] = {
8142         0x01,                           /* handle */
8143         0x03,                           /* complete data */
8144         0x01,                           /* controller should not fragment */
8145         0x0a,                   /* scan rsp data len */
8146         0x03,                   /* AD len */
8147         0x19,                   /* AD type: external appearance */
8148         0x40, 0x03,             /* some custom appearance */
8149         0x05,                   /* AD len */
8150         0x03,                   /* AD type: all 16 bit service class UUIDs */
8151         0x0d, 0x18, 0x0f, 0x18, /* heart rate monitor, battery service */
8152 };
8153
8154 static const struct generic_data add_ext_advertising_success_7 = {
8155         .setup_settings = settings_powered_le,
8156         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8157         .send_param = add_advertising_param_scanrsp,
8158         .send_len = sizeof(add_advertising_param_scanrsp),
8159         .expect_param = advertising_instance1_param,
8160         .expect_len = sizeof(advertising_instance1_param),
8161         .expect_status = MGMT_STATUS_SUCCESS,
8162         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
8163         .expect_alt_ev_param = advertising_instance1_param,
8164         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8165         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
8166         .expect_hci_param = set_ext_scan_rsp_uuid,
8167         .expect_hci_len = sizeof(set_ext_scan_rsp_uuid),
8168 };
8169
8170 static uint8_t set_connectable_on_ext_adv_param[] = {
8171         0x01,                                   /* Handle */
8172         0x13, 0x00,                     /* Event type */
8173         0x00, 0x08, 0x00,               /* min_interval */
8174         0x00, 0x08, 0x00,               /* max_interval */
8175         0x07,                                   /* channel_map */
8176         0x00,                                   /* own_addr_type */
8177         0x00,                                   /* peer_addr_type */
8178         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* peer_addr */
8179         0x00,                                   /* filter_policy */
8180         127,                                    /* Tx power */
8181         0x01,                                   /* Primary PHY */
8182         0x00,                                   /* primary adv max skip */
8183         0x01,                                   /* Secondary PHY */
8184         0x00,                                   /* adv sid*/
8185         0x00,                                   /* Scan req notification */
8186 };
8187
8188 static const struct generic_data add_ext_advertising_success_8 = {
8189         .setup_settings = settings_powered_le,
8190         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8191         .send_param = add_advertising_param_connectable,
8192         .send_len = sizeof(add_advertising_param_connectable),
8193         .expect_param = advertising_instance1_param,
8194         .expect_len = sizeof(advertising_instance1_param),
8195         .expect_status = MGMT_STATUS_SUCCESS,
8196         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8197         .expect_hci_param = set_connectable_on_ext_adv_param,
8198         .expect_hci_len = sizeof(set_connectable_on_ext_adv_param),
8199 };
8200
8201 static const uint8_t set_ext_adv_data_general_discov[] = {
8202         0x01,                           /* handle */
8203         0x03,                           /* complete data */
8204         0x01,                           /* controller should not fragment */
8205         0x0c,                   /* adv data len */
8206         0x02,                   /* AD len */
8207         0x01,                   /* AD type: flags */
8208         0x02,                   /* general discoverable */
8209         0x03,                   /* AD len */
8210         0x02,                   /* AD type: some 16bit service class UUIDs */
8211         0x0d, 0x18,             /* heart rate monitor */
8212         0x04,                   /* AD len */
8213         0xff,                   /* AD type: manufacturer specific data */
8214         0x01, 0x02, 0x03,       /* custom advertising data */
8215 };
8216
8217 static const uint8_t set_ext_adv_data_limited_discov[] = {
8218         0x01,                           /* handle */
8219         0x03,                           /* complete data */
8220         0x01,                           /* controller should not fragment */
8221         0x0c,                   /* adv data len */
8222         0x02,                   /* AD len */
8223         0x01,                   /* AD type: flags */
8224         0x01,                   /* limited discoverable */
8225         /* rest: same as before */
8226         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
8227 };
8228
8229 static const uint8_t set_ext_adv_data_uuid_txpwr[] = {
8230         0x01,                           /* handle */
8231         0x03,                           /* complete data */
8232         0x01,                           /* controller should not fragment */
8233         0x0c,                   /* adv data len */
8234         0x03,                   /* AD len */
8235         0x02,                   /* AD type: some 16bit service class UUIDs */
8236         0x0d, 0x18,             /* heart rate monitor */
8237         0x04,                   /* AD len */
8238         0xff,                   /* AD type: manufacturer specific data */
8239         0x01, 0x02, 0x03,       /* custom advertising data */
8240         0x02,                   /* AD len */
8241         0x0a,                   /* AD type: tx power */
8242         0x00,                   /* tx power */
8243 };
8244
8245 static const struct generic_data add_ext_advertising_success_9 = {
8246         .setup_settings = settings_powered_le,
8247         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8248         .send_param = add_advertising_param_general_discov,
8249         .send_len = sizeof(add_advertising_param_general_discov),
8250         .expect_param = advertising_instance1_param,
8251         .expect_len = sizeof(advertising_instance1_param),
8252         .expect_status = MGMT_STATUS_SUCCESS,
8253         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8254         .expect_hci_param = set_ext_adv_data_general_discov,
8255         .expect_hci_len = sizeof(set_ext_adv_data_general_discov),
8256 };
8257
8258 static const struct generic_data add_ext_advertising_success_10 = {
8259         .setup_settings = settings_powered_le,
8260         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8261         .send_param = add_advertising_param_limited_discov,
8262         .send_len = sizeof(add_advertising_param_limited_discov),
8263         .expect_param = advertising_instance1_param,
8264         .expect_len = sizeof(advertising_instance1_param),
8265         .expect_status = MGMT_STATUS_SUCCESS,
8266         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8267         .expect_hci_param = set_ext_adv_data_limited_discov,
8268         .expect_hci_len = sizeof(set_ext_adv_data_limited_discov),
8269 };
8270
8271 static const struct generic_data add_ext_advertising_success_11 = {
8272         .setup_settings = settings_powered_le_discoverable,
8273         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8274         .send_param = add_advertising_param_managed,
8275         .send_len = sizeof(add_advertising_param_managed),
8276         .expect_param = advertising_instance1_param,
8277         .expect_len = sizeof(advertising_instance1_param),
8278         .expect_status = MGMT_STATUS_SUCCESS,
8279         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8280         .expect_hci_param = set_ext_adv_data_general_discov,
8281         .expect_hci_len = sizeof(set_ext_adv_data_general_discov),
8282 };
8283
8284 static const struct generic_data add_ext_advertising_success_12 = {
8285         .setup_settings = settings_powered_le_discoverable,
8286         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8287         .send_param = add_advertising_param_txpwr,
8288         .send_len = sizeof(add_advertising_param_txpwr),
8289         .expect_param = advertising_instance1_param,
8290         .expect_len = sizeof(advertising_instance1_param),
8291         .expect_status = MGMT_STATUS_SUCCESS,
8292         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8293         .expect_hci_param = set_ext_adv_data_uuid_txpwr,
8294         .expect_hci_len = sizeof(set_ext_adv_data_uuid_txpwr),
8295 };
8296
8297 static uint8_t set_connectable_off_scan_ext_adv_param[] = {
8298         0x01,                                   /* Handle */
8299         0x12, 0x00,                             /* Event type */
8300         0x00, 0x08, 0x00,               /* min_interval */
8301         0x00, 0x08,     0x00,           /* max_interval */
8302         0x07,                                   /* channel_map */
8303         0x01,                                   /* own_addr_type */
8304         0x00,                                   /* peer_addr_type */
8305         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
8306         0x00,                                   /* filter_policy */
8307         127,                                    /* Tx power */
8308         0x01,                                   /* Primary PHY */
8309         0x00,                                   /* primary adv max skip */
8310         0x01,                                   /* Secondary PHY */
8311         0x00,                                   /* adv sid*/
8312         0x00,                                   /* Scan req notification */
8313 };
8314
8315 static const struct generic_data add_ext_advertising_success_13 = {
8316         .setup_settings = settings_powered_le,
8317         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8318         .send_param = add_advertising_param_scanrsp,
8319         .send_len = sizeof(add_advertising_param_scanrsp),
8320         .expect_param = advertising_instance1_param,
8321         .expect_len = sizeof(advertising_instance1_param),
8322         .expect_status = MGMT_STATUS_SUCCESS,
8323         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8324         .expect_hci_param = set_connectable_off_scan_ext_adv_param,
8325         .expect_hci_len = sizeof(set_connectable_off_scan_ext_adv_param),
8326 };
8327
8328 static uint8_t set_connectable_off_ext_adv_param[] = {
8329         0x01,                                   /* Handle */
8330         0x10, 0x00,                     /* Event type */
8331         0x00, 0x08, 0x00,               /* min_interval */
8332         0x00, 0x08, 0x00,               /* max_interval */
8333         0x07,                                   /* channel_map */
8334         0x01,                                   /* own_addr_type */
8335         0x00,                                   /* peer_addr_type */
8336         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* peer_addr */
8337         0x00,                                   /* filter_policy */
8338         127,                                    /* Tx power */
8339         0x01,                                   /* Primary PHY */
8340         0x00,                                   /* primary adv max skip */
8341         0x01,                                   /* Secondary PHY */
8342         0x00,                                   /* adv sid*/
8343         0x00,                                   /* Scan req notification */
8344 };
8345
8346 static const struct generic_data add_ext_advertising_success_14 = {
8347         .setup_settings = settings_powered_le,
8348         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8349         .send_param = add_advertising_param_uuid,
8350         .send_len = sizeof(add_advertising_param_uuid),
8351         .expect_param = advertising_instance1_param,
8352         .expect_len = sizeof(advertising_instance1_param),
8353         .expect_status = MGMT_STATUS_SUCCESS,
8354         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8355         .expect_hci_param = set_connectable_off_ext_adv_param,
8356         .expect_hci_len = sizeof(set_connectable_off_ext_adv_param),
8357 };
8358
8359 static const struct generic_data add_ext_advertising_success_15 = {
8360         .setup_settings = settings_powered_le_connectable,
8361         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8362         .send_param = add_advertising_param_uuid,
8363         .send_len = sizeof(add_advertising_param_uuid),
8364         .expect_param = advertising_instance1_param,
8365         .expect_len = sizeof(advertising_instance1_param),
8366         .expect_status = MGMT_STATUS_SUCCESS,
8367         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8368         .expect_hci_param = set_connectable_on_ext_adv_param,
8369         .expect_hci_len = sizeof(set_connectable_on_ext_adv_param),
8370 };
8371
8372 static uint8_t preset_connectable_on_ext_adv_param[] = {
8373         0x01,                                   /* Handle */
8374         0x13, 0x00,                             /* Event type */
8375         0x00, 0x08, 0x00,                       /* min_interval */
8376         0x00, 0x08, 0x00,                       /* max_interval */
8377         0x07,                                   /* channel_map */
8378         0x00,                                   /* own_addr_type */
8379         0x00,                                   /* peer_addr_type */
8380         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
8381         0x00,                                   /* filter_policy */
8382         0x00,                                   /* Tx power */
8383         0x01,                                   /* Primary PHY */
8384         0x00,                                   /* primary adv max skip */
8385         0x01,                                   /* Secondary PHY */
8386         0x00,                                   /* adv sid*/
8387         0x00,                                   /* Scan req notification */
8388 };
8389
8390 static const struct generic_data add_ext_advertising_success_16 = {
8391         .send_opcode = MGMT_OP_SET_CONNECTABLE,
8392         .send_param = set_connectable_on_param,
8393         .send_len = sizeof(set_connectable_on_param),
8394         .expect_status = MGMT_STATUS_SUCCESS,
8395         .expect_param = set_connectable_settings_param_3,
8396         .expect_len = sizeof(set_connectable_settings_param_3),
8397         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8398         .expect_hci_param = preset_connectable_on_ext_adv_param,
8399         .expect_hci_len = sizeof(preset_connectable_on_ext_adv_param),
8400 };
8401
8402 static uint8_t preset_connectable_off_ext_adv_param[] = {
8403         0x01,                                   /* Handle */
8404         0x10, 0x00,                             /* Event type */
8405         0x00, 0x08, 0x00,                       /* min_interval */
8406         0x00, 0x08, 0x00,                       /* max_interval */
8407         0x07,                                   /* channel_map */
8408         0x01,                                   /* own_addr_type */
8409         0x00,                                   /* peer_addr_type */
8410         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
8411         0x00,                                   /* filter_policy */
8412         0x00,                                   /* Tx power */
8413         0x01,                                   /* Primary PHY */
8414         0x00,                                   /* primary adv max skip */
8415         0x01,                                   /* Secondary PHY */
8416         0x00,                                   /* adv sid*/
8417         0x00,                                   /* Scan req notification */
8418 };
8419
8420 static const struct generic_data add_ext_advertising_success_17 = {
8421         .send_opcode = MGMT_OP_SET_CONNECTABLE,
8422         .send_param = set_connectable_off_param,
8423         .send_len = sizeof(set_connectable_off_param),
8424         .expect_status = MGMT_STATUS_SUCCESS,
8425         .expect_param = set_le_settings_param_2,
8426         .expect_len = sizeof(set_le_settings_param_2),
8427         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8428         .expect_hci_param = preset_connectable_off_ext_adv_param,
8429         .expect_hci_len = sizeof(preset_connectable_off_ext_adv_param),
8430 };
8431
8432 static const struct generic_data add_ext_advertising_le_off = {
8433         .send_opcode = MGMT_OP_SET_LE,
8434         .send_param = set_le_off_param,
8435         .send_len = sizeof(set_le_off_param),
8436         .expect_status = MGMT_STATUS_SUCCESS,
8437         .expect_param = set_le_settings_param_off,
8438         .expect_len = sizeof(set_le_settings_param_off),
8439         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8440         .expect_alt_ev_param = advertising_instance1_param,
8441         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8442 };
8443
8444 static const struct generic_data add_ext_advertising_success_18 = {
8445         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8446         .send_param = add_advertising_param_uuid,
8447         .send_len = sizeof(add_advertising_param_uuid),
8448         .expect_param = advertising_instance1_param,
8449         .expect_len = sizeof(advertising_instance1_param),
8450         .expect_status = MGMT_STATUS_SUCCESS,
8451         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8452         .expect_hci_param = set_ext_adv_data_uuid,
8453         .expect_hci_len = sizeof(set_ext_adv_data_uuid),
8454 };
8455
8456 static const char set_ext_adv_disable_param[] = {
8457         0x00, 0x00,
8458 };
8459
8460 static const char set_ext_adv_disable_param_1[] = {
8461         0x00, 0x01, 0x01, 0x00, 0x00, 0x00
8462 };
8463
8464 static const struct generic_data add_ext_advertising_timeout_expired = {
8465         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8466         .expect_alt_ev_param = advertising_instance1_param,
8467         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8468 };
8469
8470 static const struct generic_data remove_ext_advertising_fail_1 = {
8471         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
8472         .send_param = remove_advertising_param_1,
8473         .send_len = sizeof(remove_advertising_param_1),
8474         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8475 };
8476
8477 static const struct generic_data remove_ext_advertising_success_1 = {
8478         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
8479         .send_param = remove_advertising_param_1,
8480         .send_len = sizeof(remove_advertising_param_1),
8481         .expect_status = MGMT_STATUS_SUCCESS,
8482         .expect_param = remove_advertising_param_1,
8483         .expect_len = sizeof(remove_advertising_param_1),
8484         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8485         .expect_alt_ev_param = advertising_instance1_param,
8486         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8487         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
8488         .expect_hci_param = set_ext_adv_disable_param_1,
8489         .expect_hci_len = sizeof(set_ext_adv_disable_param_1),
8490 };
8491
8492 static const struct generic_data remove_ext_advertising_success_2 = {
8493         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
8494         .send_param = remove_advertising_param_2,
8495         .send_len = sizeof(remove_advertising_param_2),
8496         .expect_status = MGMT_STATUS_SUCCESS,
8497         .expect_param = remove_advertising_param_2,
8498         .expect_len = sizeof(remove_advertising_param_2),
8499         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8500         .expect_alt_ev_param = advertising_instance1_param,
8501         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8502         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
8503         .expect_hci_param = set_ext_adv_disable_param,
8504         .expect_hci_len = sizeof(set_ext_adv_disable_param),
8505 };
8506
8507 static const uint8_t set_ext_adv_data_test2[] = {
8508         0x02,                           /* handle */
8509         0x03,                           /* complete data */
8510         0x01,                           /* controller should not fragment */
8511         0x07,                           /* adv data len */
8512         0x06,                           /* AD len */
8513         0x08,                           /* AD type: shortened local name */
8514         0x74, 0x65, 0x73, 0x74, 0x32,   /* "test2" */
8515 };
8516
8517 static const struct generic_data multi_ext_advertising = {
8518         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8519         .expect_alt_ev_param = advertising_instance1_param,
8520         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8521 };
8522
8523 static const struct generic_data multi_ext_advertising_add_second = {
8524         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8525         .send_param = add_advertising_param_test2,
8526         .send_len = sizeof(add_advertising_param_test2),
8527         .expect_param = advertising_instance2_param,
8528         .expect_len = sizeof(advertising_instance2_param),
8529         .expect_status = MGMT_STATUS_SUCCESS,
8530         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
8531         .expect_alt_ev_param = advertising_instance2_param,
8532         .expect_alt_ev_len = sizeof(advertising_instance2_param),
8533         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8534         .expect_hci_param = set_ext_adv_data_test2,
8535         .expect_hci_len = sizeof(set_ext_adv_data_test2),
8536 };
8537
8538 static const char multi_ext_adv_hci_params_1[] = {
8539         0x01,                                   /* handle */
8540         0x10, 0x00,                             /* evt_properties */
8541         0x00, 0x08, 0x00,                       /* min_interval */
8542         0x00, 0x08, 0x00,                       /* max_interval */
8543         0x07,                                   /* channel_map */
8544         0x01,                                   /* own_addr_type */
8545         0x00,                                   /* peer_addr_type */
8546         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
8547         0x00,                                   /* filter_policy */
8548         0x7f,                                   /* tx_power */
8549         0x01,                                   /* primary_phy */
8550         0x00,                                   /* secondary_max_skip */
8551         0x01,                                   /* secondary_phy */
8552         0x00,                                   /* sid */
8553         0x00,                                   /* notif_enable */
8554 };
8555
8556 static const char multi_ext_adv_hci_params_2[] = {
8557         0x02,                                   /* handle */
8558         0x10, 0x00,                             /* evt_properties */
8559         0x00, 0x08, 0x00,                       /* min_interval */
8560         0x00, 0x08, 0x00,                       /* max_interval */
8561         0x07,                                   /* channel_map */
8562         0x01,                                   /* own_addr_type */
8563         0x00,                                   /* peer_addr_type */
8564         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
8565         0x00,                                   /* filter_policy */
8566         0x7f,                                   /* tx_power */
8567         0x01,                                   /* primary_phy */
8568         0x00,                                   /* secondary_max_skip */
8569         0x01,                                   /* secondary_phy */
8570         0x00,                                   /* sid */
8571         0x00,                                   /* notif_enable */
8572 };
8573
8574 static const uint8_t le_set_ext_adv_enable_inst_2[] = {
8575         0x01, 0x01, 0x02, 0x64, 0x00, 0x00,
8576 };
8577
8578 static const struct hci_cmd_data multi_ext_adv_add_second_hci_cmds[] = {
8579         {
8580                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8581                 .len = sizeof(multi_ext_adv_hci_params_2),
8582                 .param = multi_ext_adv_hci_params_2,
8583         },
8584         {
8585                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8586                 .len = sizeof(set_ext_adv_data_test2),
8587                 .param = set_ext_adv_data_test2,
8588         },
8589         {
8590                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
8591                 .len = sizeof(le_set_ext_adv_enable_inst_2),
8592                 .param = le_set_ext_adv_enable_inst_2,
8593         },
8594 };
8595
8596 static const struct generic_data multi_ext_advertising_add_second_2 = {
8597         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8598         .send_param = add_advertising_param_test2,
8599         .send_len = sizeof(add_advertising_param_test2),
8600         .expect_param = advertising_instance2_param,
8601         .expect_len = sizeof(advertising_instance2_param),
8602         .expect_status = MGMT_STATUS_SUCCESS,
8603         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
8604         .expect_alt_ev_param = advertising_instance2_param,
8605         .expect_alt_ev_len = sizeof(advertising_instance2_param),
8606         .expect_hci_list = multi_ext_adv_add_second_hci_cmds,
8607 };
8608
8609 /* add advertising command for a second instance */
8610 static const uint8_t add_advertising_param_test4[] = {
8611         0x04,                           /* adv instance */
8612         0x00, 0x00, 0x00, 0x00,         /* flags: none */
8613         0x00, 0x00,                     /* duration: default */
8614         0x01, 0x00,                     /* timeout: 1 second */
8615         0x07,                           /* adv data len */
8616         0x00,                           /* scan rsp len */
8617         /* adv data: */
8618         0x06,                           /* AD len */
8619         0x08,                           /* AD type: shortened local name */
8620         0x74, 0x65, 0x73, 0x74, 0x32,   /* "test2" */
8621 };
8622
8623 static const struct generic_data multi_ext_advertising_add_adv_4 = {
8624         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8625         .send_param = add_advertising_param_test4,
8626         .send_len = sizeof(add_advertising_param_test4),
8627         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8628 };
8629
8630 static const struct hci_cmd_data multi_ext_adv_remove_adv_hci_cmds[] = {
8631         {
8632                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
8633                 .len = sizeof(set_ext_adv_disable_param_1),
8634                 .param = set_ext_adv_disable_param_1,
8635         },
8636         {
8637                 .opcode = BT_HCI_CMD_LE_REMOVE_ADV_SET,
8638                 .len = sizeof(advertising_instance1_param),
8639                 .param = advertising_instance1_param,
8640         },
8641 };
8642
8643 static const struct generic_data multi_ext_advertising_remove = {
8644         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
8645         .send_param = advertising_instance1_param,
8646         .send_len = sizeof(advertising_instance1_param),
8647         .expect_param = advertising_instance1_param,
8648         .expect_len = sizeof(advertising_instance1_param),
8649         .expect_status = MGMT_STATUS_SUCCESS,
8650         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8651         .expect_alt_ev_param = advertising_instance1_param,
8652         .expect_alt_ev_len = sizeof(advertising_instance1_param),
8653         .expect_hci_list = multi_ext_adv_remove_adv_hci_cmds,
8654 };
8655
8656 static const uint8_t advertising_instance0_param[] = {
8657         0x00,
8658 };
8659
8660 static const uint8_t set_ext_adv_remove_all_param[] = {
8661         0x00, 0x00,
8662 };
8663
8664 static const struct hci_cmd_data multi_ext_adv_remove_all_adv_hci_cmds[] = {
8665         {
8666                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
8667                 .len = sizeof(set_ext_adv_remove_all_param),
8668                 .param = set_ext_adv_remove_all_param,
8669         },
8670         {
8671                 .opcode = BT_HCI_CMD_LE_CLEAR_ADV_SETS,
8672         },
8673 };
8674
8675 static const struct generic_data multi_ext_advertising_remove_all = {
8676         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
8677         .send_param = advertising_instance0_param,
8678         .send_len = sizeof(advertising_instance0_param),
8679         .expect_param = advertising_instance0_param,
8680         .expect_len = sizeof(advertising_instance0_param),
8681         .expect_status = MGMT_STATUS_SUCCESS,
8682         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
8683         .expect_alt_ev_param = advertising_instance2_param,
8684         .expect_alt_ev_len = sizeof(advertising_instance2_param),
8685         .expect_hci_list = multi_ext_adv_remove_all_adv_hci_cmds,
8686 };
8687
8688 static const struct hci_cmd_data multi_ext_adv_add_2_advs_hci_cmds[] = {
8689         {
8690                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8691                 .len = sizeof(multi_ext_adv_hci_params_2),
8692                 .param = multi_ext_adv_hci_params_2,
8693         },
8694         {
8695                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8696                 .len = sizeof(set_ext_adv_data_test2),
8697                 .param = set_ext_adv_data_test2,
8698         },
8699         {
8700                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8701                 .len = sizeof(multi_ext_adv_hci_params_1),
8702                 .param = multi_ext_adv_hci_params_1,
8703         },
8704         {
8705                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_DATA,
8706                 .len = sizeof(set_ext_adv_data_test1),
8707                 .param = set_ext_adv_data_test1,
8708         },
8709 };
8710
8711 static const struct generic_data multi_ext_advertising_add_no_power = {
8712         .send_opcode = MGMT_OP_SET_POWERED,
8713         .send_param = set_powered_on_param,
8714         .send_len = sizeof(set_powered_on_param),
8715         .expect_status = MGMT_STATUS_SUCCESS,
8716         .expect_param = set_powered_adv_instance_settings_param,
8717         .expect_len = sizeof(set_powered_adv_instance_settings_param),
8718         .expect_hci_list = multi_ext_adv_add_2_advs_hci_cmds,
8719 };
8720
8721 static const struct generic_data add_ext_advertising_empty_scrsp = {
8722         .setup_settings = settings_powered_le,
8723         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
8724         .setup_send_param = set_local_name_param,
8725         .setup_send_len = sizeof(set_local_name_param),
8726         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8727         .send_param = add_advertising_param_empty,
8728         .send_len = sizeof(add_advertising_param_empty),
8729         .expect_status = MGMT_STATUS_SUCCESS,
8730         .expect_param = advertising_instance1_param,
8731         .expect_len = sizeof(advertising_instance1_param),
8732 };
8733
8734 static const struct generic_data add_ext_advertising_scrsp_data_only_ok = {
8735         .setup_settings = settings_powered_le,
8736         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8737         .send_param = add_advertising_param_scrsp_data_only_ok,
8738         .send_len = sizeof(add_advertising_param_scrsp_data_only_ok),
8739         .expect_status = MGMT_STATUS_SUCCESS,
8740         .expect_param = advertising_instance1_param,
8741         .expect_len = sizeof(advertising_instance1_param),
8742 };
8743
8744 static const struct generic_data add_ext_advertising_scrsp_data_only_too_long = {
8745         .setup_settings = settings_powered_le,
8746         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8747         .send_param = add_advertising_param_scrsp_data_only_too_long,
8748         .send_len = sizeof(add_advertising_param_scrsp_data_only_too_long),
8749         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8750         .expect_param = NULL,
8751         .expect_len = 0,
8752 };
8753
8754 static const struct generic_data add_ext_advertising_scrsp_appear_data_ok = {
8755         .setup_settings = settings_powered_le,
8756         .setup_send_opcode = MGMT_OP_SET_APPEARANCE,
8757         .setup_send_param = set_appearance_param,
8758         .setup_send_len = sizeof(set_appearance_param),
8759         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8760         .send_param = add_advertising_param_scrsp_appear_data_ok,
8761         .send_len = sizeof(add_advertising_param_scrsp_appear_data_ok),
8762         .expect_status = MGMT_STATUS_SUCCESS,
8763         .expect_param = advertising_instance1_param,
8764         .expect_len = sizeof(advertising_instance1_param),
8765 };
8766
8767 static const struct generic_data add_ext_advertising_scrsp_appear_data_too_long = {
8768         .setup_settings = settings_powered_le,
8769         .setup_send_opcode = MGMT_OP_SET_APPEARANCE,
8770         .setup_send_param = set_appearance_param,
8771         .setup_send_len = sizeof(set_appearance_param),
8772         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8773         .send_param = add_advertising_param_scrsp_appear_data_too_long,
8774         .send_len = sizeof(add_advertising_param_scrsp_appear_data_too_long),
8775         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8776         .expect_param = NULL,
8777         .expect_len = 0,
8778 };
8779
8780 static const struct generic_data add_ext_advertising_scrsp_appear_null = {
8781         .setup_settings = settings_powered_le,
8782         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8783         .send_param = add_advertising_param_scrsp_appear_null,
8784         .send_len = sizeof(add_advertising_param_scrsp_appear_null),
8785         .expect_status = MGMT_STATUS_SUCCESS,
8786         .expect_param = advertising_instance1_param,
8787         .expect_len = sizeof(advertising_instance1_param),
8788 };
8789
8790 static const uint8_t ext_scan_rsp_data_empty[] = {
8791         0x01,                           /* handle */
8792         0x03,                           /* complete data */
8793         0x01,                           /* controller should not fragment */
8794         0x01, /* scan rsp data len */
8795         0x00, /* scan rsp data */
8796 };
8797
8798 static const struct generic_data add_ext_advertising_no_name_set = {
8799         .setup_settings = settings_powered_le,
8800         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8801         .send_param = add_advertising_empty_param,
8802         .send_len = sizeof(add_advertising_empty_param),
8803         .expect_status = MGMT_STATUS_SUCCESS,
8804         .expect_param = advertising_instance1_param,
8805         .expect_len = sizeof(advertising_instance1_param),
8806         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
8807         .expect_hci_param = ext_scan_rsp_data_empty,
8808         .expect_hci_len = sizeof(ext_scan_rsp_data_empty),
8809 };
8810
8811 static const uint8_t set_ext_scan_rsp_data_name_fits_in_scrsp[] = {
8812         0x01,                           /* handle */
8813         0x03,                           /* complete data */
8814         0x01,                           /* controller should not fragment */
8815         0x0c, /* Scan rsp data len */
8816         0x0b, /* Local name data len */
8817         0x09, /* Complete name */
8818         /* "Test name" */
8819         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x00,
8820 };
8821
8822 static const struct generic_data add_ext_advertising_name_fits_in_scrsp = {
8823         .setup_settings = settings_powered_le,
8824         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
8825         .setup_send_param = &set_local_name_cp,
8826         .setup_send_len = sizeof(set_local_name_cp),
8827         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8828         .send_param = add_advertising_param_name,
8829         .send_len = sizeof(add_advertising_param_name),
8830         .expect_status = MGMT_STATUS_SUCCESS,
8831         .expect_param = advertising_instance1_param,
8832         .expect_len = sizeof(advertising_instance1_param),
8833         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
8834         .expect_hci_param = set_ext_scan_rsp_data_name_fits_in_scrsp,
8835         .expect_hci_len = sizeof(set_ext_scan_rsp_data_name_fits_in_scrsp),
8836 };
8837
8838 static const uint8_t set_ext_scan_rsp_data_shortened_name_fits[] = {
8839         0x01,                           /* handle */
8840         0x03,                           /* complete data */
8841         0x01,                           /* controller should not fragment */
8842         0x0d, /* Scan rsp data len */
8843         0x0c, /* Local name data len */
8844         0x08, /* Short name */
8845         /* "Test name1" */
8846         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x31, 0x00,
8847 };
8848
8849 static const struct generic_data add_ext_advertising_shortened_name_in_scrsp = {
8850         .setup_settings = settings_powered_le,
8851         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
8852         .setup_send_param = &set_local_name_longer_cp,
8853         .setup_send_len = sizeof(set_local_name_longer_cp),
8854         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8855         .send_param = add_advertising_param_name,
8856         .send_len = sizeof(add_advertising_param_name),
8857         .expect_status = MGMT_STATUS_SUCCESS,
8858         .expect_param = advertising_instance1_param,
8859         .expect_len = sizeof(advertising_instance1_param),
8860         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
8861         .expect_hci_param = set_ext_scan_rsp_data_shortened_name_fits,
8862         .expect_hci_len = sizeof(set_ext_scan_rsp_data_shortened_name_fits),
8863 };
8864
8865 static const uint8_t set_ext_scan_rsp_data_param_name_data_ok[] = {
8866         0x01,                           /* handle */
8867         0x03,                           /* complete data */
8868         0x01,                           /* controller should not fragment */
8869         0x1e, /* Scan rsp data len */
8870         /* scan rsp data */
8871         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8872         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8873         0x0b, /* Local name data len */
8874         0x09, /* Complete name */
8875         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x00,
8876         /* "Test name" */
8877 };
8878
8879 static const struct generic_data add_ext_advertising_name_data_ok = {
8880         .setup_settings = settings_powered_le,
8881         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
8882         .setup_send_param = &set_local_name_cp,
8883         .setup_send_len = sizeof(set_local_name_cp),
8884         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8885         .send_param = add_advertising_param_name_data_ok,
8886         .send_len = sizeof(add_advertising_param_name_data_ok),
8887         .expect_status = MGMT_STATUS_SUCCESS,
8888         .expect_param = advertising_instance1_param,
8889         .expect_len = sizeof(advertising_instance1_param),
8890         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
8891         .expect_hci_param = set_ext_scan_rsp_data_param_name_data_ok,
8892         .expect_hci_len = sizeof(set_ext_scan_rsp_data_param_name_data_ok),
8893 };
8894
8895 static const struct generic_data add_ext_advertising_name_data_inv = {
8896         .setup_settings = settings_powered_le,
8897         .setup_send_opcode = MGMT_OP_SET_LOCAL_NAME,
8898         .setup_send_param = &set_local_name_cp,
8899         .setup_send_len = sizeof(set_local_name_cp),
8900         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8901         .send_param = add_advertising_param_name_data_inv,
8902         .send_len = sizeof(add_advertising_param_name_data_inv),
8903         .expect_status = MGMT_STATUS_INVALID_PARAMS,
8904         .expect_param = NULL,
8905         .expect_len = 0,
8906 };
8907
8908 static const uint8_t set_ext_scan_rsp_data_name_data_appear[] = {
8909         0x01,                           /* handle */
8910         0x03,                           /* complete data */
8911         0x01,                           /* controller should not fragment */
8912         0x1e, /* Scan rsp data len */
8913         0x03, /* appearance len */
8914         0x19, /* EIR_APPEARANCE */
8915         0x54, 0x65, /* appearance value */
8916         /* scan rsp data */
8917         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8918         0x00, 0x00, 0x00, 0x00,
8919         0x0b, /* Local name data len */
8920         0x09, /* Complete name */
8921         0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x00,
8922         /* "Test name" */
8923 };
8924
8925 static const struct generic_data add_ext_advertising_name_data_appear = {
8926         .setup_settings = settings_powered_le,
8927         .setup_mgmt_cmd_arr = add_advertising_mgmt_cmd_arr,
8928         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8929         .send_param = add_advertising_param_name_data_appear,
8930         .send_len = sizeof(add_advertising_param_name_data_appear),
8931         .expect_status = MGMT_STATUS_SUCCESS,
8932         .expect_param = advertising_instance1_param,
8933         .expect_len = sizeof(advertising_instance1_param),
8934         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_RSP_DATA,
8935         .expect_hci_param = set_ext_scan_rsp_data_name_data_appear,
8936         .expect_hci_len = sizeof(set_ext_scan_rsp_data_name_data_appear),
8937 };
8938
8939 /* simple add advertising command */
8940 static const uint8_t add_advertising_1m_param_uuid[] = {
8941         0x01,                   /* adv instance */
8942         0x80, 0x00, 0x00, 0x00, /* flags: 1m */
8943         0x00, 0x00,             /* duration: default */
8944         0x00, 0x00,             /* timeout: none */
8945         0x09,                   /* adv data len */
8946         0x00,                   /* scan rsp len */
8947         /* adv data: */
8948         0x03,                   /* AD len */
8949         0x02,                   /* AD type: some 16 bit service class UUIDs */
8950         0x0d, 0x18,             /* heart rate monitor */
8951         0x04,                   /* AD len */
8952         0xff,                   /* AD type: manufacturer specific data */
8953         0x01, 0x02, 0x03,       /* custom advertising data */
8954 };
8955
8956 static uint8_t set_connectable_off_ext_1m_adv_param[] = {
8957         0x01,                                   /* Handle */
8958         0x00, 0x00,                     /* Event type */
8959         0x00, 0x08, 0x00,               /* min_interval */
8960         0x00, 0x08, 0x00,               /* max_interval */
8961         0x07,                                   /* channel_map */
8962         0x01,                                   /* own_addr_type */
8963         0x00,                                   /* peer_addr_type */
8964         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* peer_addr */
8965         0x00,                                   /* filter_policy */
8966         127,                                    /* Tx power */
8967         0x01,                                   /* Primary PHY */
8968         0x00,                                   /* primary adv max skip */
8969         0x01,                                   /* Secondary PHY */
8970         0x00,                                   /* adv sid*/
8971         0x00,                                   /* Scan req notification */
8972 };
8973
8974 static const struct generic_data add_ext_advertising_success_1m = {
8975         .setup_settings = settings_powered_le,
8976         .send_opcode = MGMT_OP_ADD_ADVERTISING,
8977         .send_param = add_advertising_1m_param_uuid,
8978         .send_len = sizeof(add_advertising_1m_param_uuid),
8979         .expect_param = advertising_instance1_param,
8980         .expect_len = sizeof(advertising_instance1_param),
8981         .expect_status = MGMT_STATUS_SUCCESS,
8982         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
8983         .expect_hci_param = set_connectable_off_ext_1m_adv_param,
8984         .expect_hci_len = sizeof(set_connectable_off_ext_1m_adv_param),
8985 };
8986
8987 /* simple add advertising command */
8988 static const uint8_t add_advertising_2m_param_uuid[] = {
8989         0x01,                   /* adv instance */
8990         0x00, 0x01, 0x00, 0x00, /* flags: 2m */
8991         0x00, 0x00,             /* duration: default */
8992         0x00, 0x00,             /* timeout: none */
8993         0x09,                   /* adv data len */
8994         0x00,                   /* scan rsp len */
8995         /* adv data: */
8996         0x03,                   /* AD len */
8997         0x02,                   /* AD type: some 16 bit service class UUIDs */
8998         0x0d, 0x18,             /* heart rate monitor */
8999         0x04,                   /* AD len */
9000         0xff,                   /* AD type: manufacturer specific data */
9001         0x01, 0x02, 0x03,       /* custom advertising data */
9002 };
9003
9004 static uint8_t set_connectable_off_ext_2m_adv_param[] = {
9005         0x01,                                   /* Handle */
9006         0x00, 0x00,                     /* Event type */
9007         0x00, 0x08, 0x00,               /* min_interval */
9008         0x00, 0x08, 0x00,               /* max_interval */
9009         0x07,                                   /* channel_map */
9010         0x01,                                   /* own_addr_type */
9011         0x00,                                   /* peer_addr_type */
9012         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* peer_addr */
9013         0x00,                                   /* filter_policy */
9014         127,                                    /* Tx power */
9015         0x01,                                   /* Primary PHY */
9016         0x00,                                   /* primary adv max skip */
9017         0x02,                                   /* Secondary PHY */
9018         0x00,                                   /* adv sid*/
9019         0x00,                                   /* Scan req notification */
9020 };
9021
9022 static const struct generic_data add_ext_advertising_success_2m = {
9023         .setup_settings = settings_powered_le,
9024         .send_opcode = MGMT_OP_ADD_ADVERTISING,
9025         .send_param = add_advertising_2m_param_uuid,
9026         .send_len = sizeof(add_advertising_2m_param_uuid),
9027         .expect_param = advertising_instance1_param,
9028         .expect_len = sizeof(advertising_instance1_param),
9029         .expect_status = MGMT_STATUS_SUCCESS,
9030         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9031         .expect_hci_param = set_connectable_off_ext_2m_adv_param,
9032         .expect_hci_len = sizeof(set_connectable_off_ext_2m_adv_param),
9033 };
9034
9035 /* simple add advertising command */
9036 static const uint8_t add_advertising_coded_param_uuid[] = {
9037         0x01,                   /* adv instance */
9038         0x00, 0x02, 0x00, 0x00, /* flags: coded */
9039         0x00, 0x00,             /* duration: default */
9040         0x00, 0x00,             /* timeout: none */
9041         0x09,                   /* adv data len */
9042         0x00,                   /* scan rsp len */
9043         /* adv data: */
9044         0x03,                   /* AD len */
9045         0x02,                   /* AD type: some 16 bit service class UUIDs */
9046         0x0d, 0x18,             /* heart rate monitor */
9047         0x04,                   /* AD len */
9048         0xff,                   /* AD type: manufacturer specific data */
9049         0x01, 0x02, 0x03,       /* custom advertising data */
9050 };
9051
9052 static uint8_t set_connectable_off_ext_coded_adv_param[] = {
9053         0x01,                                   /* Handle */
9054         0x00, 0x00,                     /* Event type */
9055         0x00, 0x08, 0x00,               /* min_interval */
9056         0x00, 0x08, 0x00,               /* max_interval */
9057         0x07,                                   /* channel_map */
9058         0x01,                                   /* own_addr_type */
9059         0x00,                                   /* peer_addr_type */
9060         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* peer_addr */
9061         0x00,                                   /* filter_policy */
9062         127,                                    /* Tx power */
9063         0x03,                                   /* Primary PHY */
9064         0x00,                                   /* primary adv max skip */
9065         0x03,                                   /* Secondary PHY */
9066         0x00,                                   /* adv sid*/
9067         0x00,                                   /* Scan req notification */
9068 };
9069
9070 static const struct generic_data add_ext_advertising_success_coded = {
9071         .setup_settings = settings_powered_le,
9072         .send_opcode = MGMT_OP_ADD_ADVERTISING,
9073         .send_param = add_advertising_coded_param_uuid,
9074         .send_len = sizeof(add_advertising_coded_param_uuid),
9075         .expect_param = advertising_instance1_param,
9076         .expect_len = sizeof(advertising_instance1_param),
9077         .expect_status = MGMT_STATUS_SUCCESS,
9078         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9079         .expect_hci_param = set_connectable_off_ext_coded_adv_param,
9080         .expect_hci_len = sizeof(set_connectable_off_ext_coded_adv_param),
9081 };
9082
9083 /* add advertising with scan response data */
9084 static const uint8_t add_advertising_param_scanrsp_1m[] = {
9085         0x01,                                   /* Instance */
9086         0x80, 0x00, 0x00, 0x00, /* Flags: 1m*/
9087         0x00, 0x00,                             /* Duration */
9088         0x00, 0x00,                             /* Timeout */
9089         0x09,                                   /* Adv data len */
9090         0x0a,                   /* scan rsp len */
9091         /* adv data: same as before */
9092         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
9093         /* scan rsp data: */
9094         0x03,                   /* AD len */
9095         0x19,                   /* AD type: external appearance */
9096         0x40, 0x03,             /* some custom appearance */
9097         0x05,                   /* AD len */
9098         0x03,                   /* AD type: all 16 bit service class UUIDs */
9099         0x0d, 0x18,             /* heart rate monitor */
9100         0x0f, 0x18,             /* battery service */
9101 };
9102
9103 static uint8_t set_connectable_off_scan_ext_pdu_adv_param[] = {
9104         0x01,                                   /* Handle */
9105         0x02, 0x00,                             /* Event type */
9106         0x00, 0x08, 0x00,               /* min_interval */
9107         0x00, 0x08,     0x00,           /* max_interval */
9108         0x07,                                   /* channel_map */
9109         0x01,                                   /* own_addr_type */
9110         0x00,                                   /* peer_addr_type */
9111         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
9112         0x00,                                   /* filter_policy */
9113         127,                                    /* Tx power */
9114         0x01,                                   /* Primary PHY */
9115         0x00,                                   /* primary adv max skip */
9116         0x01,                                   /* Secondary PHY */
9117         0x00,                                   /* adv sid*/
9118         0x00,                                   /* Scan req notification */
9119 };
9120
9121 static const struct generic_data add_ext_advertising_success_scannable = {
9122         .setup_settings = settings_powered_le,
9123         .send_opcode = MGMT_OP_ADD_ADVERTISING,
9124         .send_param = add_advertising_param_scanrsp_1m,
9125         .send_len = sizeof(add_advertising_param_scanrsp_1m),
9126         .expect_param = advertising_instance1_param,
9127         .expect_len = sizeof(advertising_instance1_param),
9128         .expect_status = MGMT_STATUS_SUCCESS,
9129         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9130         .expect_hci_param = set_connectable_off_scan_ext_pdu_adv_param,
9131         .expect_hci_len = sizeof(set_connectable_off_scan_ext_pdu_adv_param),
9132 };
9133
9134 static uint8_t set_connectable_on_ext_pdu_adv_param[] = {
9135         0x01,                                   /* Handle */
9136         0x01, 0x00,                             /* Event type */
9137         0x00, 0x08, 0x00,               /* min_interval */
9138         0x00, 0x08,     0x00,           /* max_interval */
9139         0x07,                                   /* channel_map */
9140         0x00,                                   /* own_addr_type */
9141         0x00,                                   /* peer_addr_type */
9142         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
9143         0x00,                                   /* filter_policy */
9144         127,                                    /* Tx power */
9145         0x01,                                   /* Primary PHY */
9146         0x00,                                   /* primary adv max skip */
9147         0x01,                                   /* Secondary PHY */
9148         0x00,                                   /* adv sid*/
9149         0x00,                                   /* Scan req notification */
9150 };
9151
9152 static const struct generic_data add_ext_advertising_success_connectable = {
9153         .setup_settings = settings_powered_le_connectable,
9154         .send_opcode = MGMT_OP_ADD_ADVERTISING,
9155         .send_param = add_advertising_1m_param_uuid,
9156         .send_len = sizeof(add_advertising_1m_param_uuid),
9157         .expect_param = advertising_instance1_param,
9158         .expect_len = sizeof(advertising_instance1_param),
9159         .expect_status = MGMT_STATUS_SUCCESS,
9160         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9161         .expect_hci_param = set_connectable_on_ext_pdu_adv_param,
9162         .expect_hci_len = sizeof(set_connectable_on_ext_pdu_adv_param),
9163 };
9164
9165 static const struct generic_data add_ext_advertising_success_conn_scan = {
9166         .setup_settings = settings_powered_le_connectable,
9167         .send_opcode = MGMT_OP_ADD_ADVERTISING,
9168         .send_param = add_advertising_param_scanrsp_1m,
9169         .send_len = sizeof(add_advertising_param_scanrsp_1m),
9170         .expect_param = advertising_instance1_param,
9171         .expect_len = sizeof(advertising_instance1_param),
9172         .expect_status = MGMT_STATUS_SUCCESS,
9173         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9174         .expect_hci_param = set_connectable_on_ext_pdu_adv_param,
9175         .expect_hci_len = sizeof(set_connectable_on_ext_pdu_adv_param),
9176 };
9177
9178 static void setup_add_adv_param_1m(struct mgmt_cp_add_advertising *cp,
9179                                                         uint8_t instance)
9180 {
9181         memset(cp, 0, sizeof(*cp));
9182         cp->instance = instance;
9183         cp->flags = cpu_to_le32(MGMT_ADV_FLAG_SEC_1M);
9184         cp->adv_data_len = TESTER_ADD_ADV_DATA_LEN;
9185         cp->data[0] = TESTER_ADD_ADV_DATA_LEN - 1; /* AD len */
9186         cp->data[1] = 0x08; /* AD type: shortened local name */
9187         cp->data[2] = 't';  /* adv data ... */
9188         cp->data[3] = 'e';
9189         cp->data[4] = 's';
9190         cp->data[5] = 't';
9191         cp->data[6] = '0' + instance;
9192 }
9193
9194 static void setup_add_advertising_1m(const void *test_data)
9195 {
9196         struct test_data *data = tester_get_data();
9197         struct mgmt_cp_add_advertising *cp;
9198         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
9199         unsigned char param[] = { 0x01 };
9200
9201         tester_print("Adding advertising instance while powered");
9202
9203         cp = (struct mgmt_cp_add_advertising *) adv_param;
9204         setup_add_adv_param_1m(cp, 1);
9205
9206         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
9207                                                 sizeof(param), &param,
9208                                                 NULL, NULL, NULL);
9209
9210         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
9211                                                 sizeof(param), &param,
9212                                                 NULL, NULL, NULL);
9213
9214         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
9215                                                 sizeof(adv_param), adv_param,
9216                                                 setup_add_advertising_callback,
9217                                                 NULL, NULL);
9218 }
9219
9220 static uint8_t preset_connectable_on_ext_pdu_adv_param[] = {
9221         0x01,                                   /* Handle */
9222         0x01, 0x00,                             /* Event type */
9223         0x00, 0x08, 0x00,                       /* min_interval */
9224         0x00, 0x08, 0x00,                       /* max_interval */
9225         0x07,                                   /* channel_map */
9226         0x00,                                   /* own_addr_type */
9227         0x00,                                   /* peer_addr_type */
9228         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
9229         0x00,                                   /* filter_policy */
9230         0x00,                                   /* Tx power */
9231         0x01,                                   /* Primary PHY */
9232         0x00,                                   /* primary adv max skip */
9233         0x01,                                   /* Secondary PHY */
9234         0x00,                                   /* adv sid*/
9235         0x00,                                   /* Scan req notification */
9236 };
9237
9238 static const struct generic_data add_ext_advertising_conn_on_1m = {
9239         .send_opcode = MGMT_OP_SET_CONNECTABLE,
9240         .send_param = set_connectable_on_param,
9241         .send_len = sizeof(set_connectable_on_param),
9242         .expect_status = MGMT_STATUS_SUCCESS,
9243         .expect_param = set_connectable_settings_param_3,
9244         .expect_len = sizeof(set_connectable_settings_param_3),
9245         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9246         .expect_hci_param = preset_connectable_on_ext_pdu_adv_param,
9247         .expect_hci_len = sizeof(preset_connectable_on_ext_pdu_adv_param),
9248 };
9249
9250 static void setup_add_advertising_connectable_1m(const void *test_data)
9251 {
9252         struct test_data *data = tester_get_data();
9253         struct mgmt_cp_add_advertising *cp;
9254         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
9255         unsigned char param[] = { 0x01 };
9256
9257         tester_print("Adding advertising instance while connectable");
9258
9259         cp = (struct mgmt_cp_add_advertising *) adv_param;
9260         setup_add_adv_param_1m(cp, 1);
9261
9262         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
9263                                                 sizeof(param), &param,
9264                                                 NULL, NULL, NULL);
9265
9266         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
9267                                                 sizeof(param), &param,
9268                                                 NULL, NULL, NULL);
9269
9270         mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
9271                                                 sizeof(param), &param,
9272                                                 NULL, NULL, NULL);
9273
9274         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
9275                                                 sizeof(adv_param), adv_param,
9276                                                 setup_add_advertising_callback,
9277                                                 NULL, NULL);
9278 }
9279
9280 static uint8_t preset_connectable_off_ext_1m_adv_param[] = {
9281         0x01,                                   /* Handle */
9282         0x00, 0x00,                             /* Event type */
9283         0x00, 0x08, 0x00,                       /* min_interval */
9284         0x00, 0x08, 0x00,                       /* max_interval */
9285         0x07,                                   /* channel_map */
9286         0x01,                                   /* own_addr_type */
9287         0x00,                                   /* peer_addr_type */
9288         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* peer_addr */
9289         0x00,                                   /* filter_policy */
9290         0x00,                                   /* Tx power */
9291         0x01,                                   /* Primary PHY */
9292         0x00,                                   /* primary adv max skip */
9293         0x01,                                   /* Secondary PHY */
9294         0x00,                                   /* adv sid*/
9295         0x00,                                   /* Scan req notification */
9296 };
9297
9298 static const struct generic_data add_ext_advertising_conn_off_1m = {
9299         .send_opcode = MGMT_OP_SET_CONNECTABLE,
9300         .send_param = set_connectable_off_param,
9301         .send_len = sizeof(set_connectable_off_param),
9302         .expect_status = MGMT_STATUS_SUCCESS,
9303         .expect_param = set_le_settings_param_2,
9304         .expect_len = sizeof(set_le_settings_param_2),
9305         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_PARAMS,
9306         .expect_hci_param = preset_connectable_off_ext_1m_adv_param,
9307         .expect_hci_len = sizeof(preset_connectable_off_ext_1m_adv_param),
9308 };
9309
9310 static const uint8_t get_phy_param[] = {
9311         0xff, 0x7f, 0x00, 0x00, /* All PHYs */
9312         0xfe, 0x79,     0x00, 0x00, /* All PHYs except BR 1M 1SLOT, LE 1M TX & LE 1M RX */
9313         0xff, 0x07, 0x00, 0x00, /* All BREDR PHYs and LE 1M TX & LE 1M RX */
9314 };
9315
9316 static const struct generic_data get_phy_success = {
9317         .setup_settings = settings_powered_le,
9318         .send_opcode = MGMT_OP_GET_PHY_CONFIGURATION,
9319         .expect_status = MGMT_STATUS_SUCCESS,
9320         .expect_param = get_phy_param,
9321         .expect_len = sizeof(get_phy_param),
9322 };
9323
9324 static const uint8_t set_phy_2m_param[] = {
9325         0xff, 0x1f,     0x00, 0x00      /* 1mtxrx 2mtxrx */
9326 };
9327
9328 static const uint8_t set_default_phy_2m_param[] = {
9329         0x00,           /* preference is there for tx and rx */
9330         0x03,           /* 1mtx, 2mtx */
9331         0x03,           /* 1mrx, 2mrx */
9332 };
9333
9334 static const struct generic_data set_phy_2m_success = {
9335         .setup_settings = settings_powered_le,
9336         .send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9337         .send_param = set_phy_2m_param,
9338         .send_len = sizeof(set_phy_2m_param),
9339         .expect_status = MGMT_STATUS_SUCCESS,
9340         .expect_hci_command = BT_HCI_CMD_LE_SET_DEFAULT_PHY,
9341         .expect_hci_param = set_default_phy_2m_param,
9342         .expect_hci_len = sizeof(set_default_phy_2m_param),
9343         .expect_alt_ev = MGMT_EV_PHY_CONFIGURATION_CHANGED,
9344         .expect_alt_ev_param = set_phy_2m_param,
9345         .expect_alt_ev_len = sizeof(set_phy_2m_param),
9346 };
9347
9348 static const uint8_t set_phy_coded_param[] = {
9349         0xff, 0x67,     0x00, 0x00      /* 1mtx, 1m rx, codedtx codedrx */
9350 };
9351
9352 static const uint8_t set_default_phy_coded_param[] = {
9353         0x00,           /* preference is there for tx and rx */
9354         0x05,           /* 1mtx, codedtx */
9355         0x05,           /* 1mrx, codedrx */
9356 };
9357
9358 static const struct generic_data set_phy_coded_success = {
9359         .setup_settings = settings_powered_le,
9360         .send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9361         .send_param = set_phy_coded_param,
9362         .send_len = sizeof(set_phy_coded_param),
9363         .expect_status = MGMT_STATUS_SUCCESS,
9364         .expect_hci_command = BT_HCI_CMD_LE_SET_DEFAULT_PHY,
9365         .expect_hci_param = set_default_phy_coded_param,
9366         .expect_hci_len = sizeof(set_default_phy_coded_param),
9367         .expect_alt_ev = MGMT_EV_PHY_CONFIGURATION_CHANGED,
9368         .expect_alt_ev_param = set_phy_coded_param,
9369         .expect_alt_ev_len = sizeof(set_phy_coded_param),
9370 };
9371
9372 static const uint8_t set_phy_all_param[] = {
9373         0xff, 0x7f,     0x00, 0x00      /* All PHYs */
9374 };
9375
9376 static const uint8_t set_default_phy_all_param[] = {
9377         0x00,           /* preference is there for tx and rx */
9378         0x07,           /* 1m 2m coded tx */
9379         0x07,           /* 1m 2m coded rx */
9380 };
9381
9382 static const struct generic_data set_phy_all_success = {
9383         .setup_settings = settings_powered_le,
9384         .send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9385         .send_param = set_phy_all_param,
9386         .send_len = sizeof(set_phy_all_param),
9387         .expect_status = MGMT_STATUS_SUCCESS,
9388         .expect_hci_command = BT_HCI_CMD_LE_SET_DEFAULT_PHY,
9389         .expect_hci_param = set_default_phy_all_param,
9390         .expect_hci_len = sizeof(set_default_phy_all_param),
9391         .expect_alt_ev = MGMT_EV_PHY_CONFIGURATION_CHANGED,
9392         .expect_alt_ev_param = set_phy_all_param,
9393         .expect_alt_ev_len = sizeof(set_phy_all_param),
9394 };
9395
9396 static const uint8_t set_phy_2m_tx_param[] = {
9397         0xff, 0x0f,     0x00, 0x00      /* 1mtxrx, 2m tx */
9398 };
9399
9400 static const uint8_t set_default_phy_2m_tx_param[] = {
9401         0x00,
9402         0x03,           /* 1m, 2m tx */
9403         0x01,           /* 1m rx */
9404 };
9405
9406 static const uint8_t set_phy_2m_tx_evt_param[] = {
9407         0xff, 0x0f,     0x00, 0x00              /*  2m tx  1m rx */
9408 };
9409
9410 static const struct generic_data set_phy_2m_tx_success = {
9411         .setup_settings = settings_powered_le,
9412         .send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9413         .send_param = set_phy_2m_tx_param,
9414         .send_len = sizeof(set_phy_2m_tx_param),
9415         .expect_status = MGMT_STATUS_SUCCESS,
9416         .expect_hci_command = BT_HCI_CMD_LE_SET_DEFAULT_PHY,
9417         .expect_hci_param = set_default_phy_2m_tx_param,
9418         .expect_hci_len = sizeof(set_default_phy_2m_tx_param),
9419         .expect_alt_ev = MGMT_EV_PHY_CONFIGURATION_CHANGED,
9420         .expect_alt_ev_param = set_phy_2m_tx_evt_param,
9421         .expect_alt_ev_len = sizeof(set_phy_2m_tx_evt_param),
9422 };
9423
9424 static const uint8_t set_phy_2m_rx_param[] = {
9425         0xff, 0x17,     0x00, 0x00      /* 1mtxrx, 2m rx */
9426 };
9427
9428 static const uint8_t set_default_phy_2m_rx_param[] = {
9429         0x00,
9430         0x01,
9431         0x03,           /* 2m rx */
9432 };
9433
9434 static const uint8_t set_phy_2m_rx_evt_param[] = {
9435         0xff, 0x17,     0x00, 0x00              /*  2m rx  1m tx */
9436 };
9437
9438 static const struct generic_data set_phy_2m_rx_success = {
9439         .setup_settings = settings_powered_le,
9440         .send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9441         .send_param = set_phy_2m_rx_param,
9442         .send_len = sizeof(set_phy_2m_rx_param),
9443         .expect_status = MGMT_STATUS_SUCCESS,
9444         .expect_hci_command = BT_HCI_CMD_LE_SET_DEFAULT_PHY,
9445         .expect_hci_param = set_default_phy_2m_rx_param,
9446         .expect_hci_len = sizeof(set_default_phy_2m_rx_param),
9447         .expect_alt_ev = MGMT_EV_PHY_CONFIGURATION_CHANGED,
9448         .expect_alt_ev_param = set_phy_2m_rx_evt_param,
9449         .expect_alt_ev_len = sizeof(set_phy_2m_rx_evt_param),
9450 };
9451
9452 static const uint8_t set_phy_param_invalid[] = {
9453         0x79, 0xfe,     0x00, 0x00      /* Set unconfigurable phy*/
9454 };
9455
9456 static const struct generic_data set_phy_invalid_param = {
9457         .setup_settings = settings_powered_le,
9458         .send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9459         .send_param = set_phy_param_invalid,
9460         .send_len = sizeof(set_phy_param_invalid),
9461         .expect_status = MGMT_STATUS_INVALID_PARAMS,
9462 };
9463
9464 static const char start_discovery_valid_ext_scan_enable[] = {
9465         0x01,
9466         0x01,
9467         0x00, 0x00,
9468         0x00, 0x00
9469 };
9470
9471 static const struct generic_data start_discovery_bredrle_ext_scan_enable = {
9472         .setup_settings = settings_powered_le,
9473         .send_opcode = MGMT_OP_START_DISCOVERY,
9474         .send_param = start_discovery_bredrle_param,
9475         .send_len = sizeof(start_discovery_bredrle_param),
9476         .expect_status = MGMT_STATUS_SUCCESS,
9477         .expect_param = start_discovery_bredrle_param,
9478         .expect_len = sizeof(start_discovery_bredrle_param),
9479         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_ENABLE,
9480         .expect_hci_param = start_discovery_valid_ext_scan_enable,
9481         .expect_hci_len = sizeof(start_discovery_valid_ext_scan_enable),
9482         .expect_alt_ev = MGMT_EV_DISCOVERING,
9483         .expect_alt_ev_param = start_discovery_evt,
9484         .expect_alt_ev_len = sizeof(start_discovery_evt),
9485 };
9486
9487 static const struct generic_data start_discovery_le_ext_scan_enable = {
9488         .setup_settings = settings_powered_le,
9489         .send_opcode = MGMT_OP_START_DISCOVERY,
9490         .send_param = start_discovery_le_param,
9491         .send_len = sizeof(start_discovery_le_param),
9492         .expect_status = MGMT_STATUS_SUCCESS,
9493         .expect_param = start_discovery_le_param,
9494         .expect_len = sizeof(start_discovery_le_param),
9495         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_ENABLE,
9496         .expect_hci_param = start_discovery_valid_ext_scan_enable,
9497         .expect_hci_len = sizeof(start_discovery_valid_ext_scan_enable),
9498         .expect_alt_ev = MGMT_EV_DISCOVERING,
9499         .expect_alt_ev_param = start_discovery_le_evt,
9500         .expect_alt_ev_len = sizeof(start_discovery_le_evt),
9501 };
9502
9503 static const char start_discovery_valid_ext_scan_param[] = {
9504         0x01,                   /* Own Addr type*/
9505         0x00,                   /* Scan filter policy*/
9506         0x01,                   /*Phys - 1m */
9507         0x01,                   /* Type */
9508         0x12, 0x00,             /* Interval */
9509         0x12, 0x00,             /* Window */
9510 };
9511
9512 static const struct generic_data start_discovery_le_ext_scan_param = {
9513         .setup_settings = settings_powered_le,
9514         .send_opcode = MGMT_OP_START_DISCOVERY,
9515         .send_param = start_discovery_le_param,
9516         .send_len = sizeof(start_discovery_le_param),
9517         .expect_status = MGMT_STATUS_SUCCESS,
9518         .expect_param = start_discovery_le_param,
9519         .expect_len = sizeof(start_discovery_le_param),
9520         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_PARAMS,
9521         .expect_hci_param = start_discovery_valid_ext_scan_param,
9522         .expect_hci_len = sizeof(start_discovery_valid_ext_scan_param),
9523         .expect_alt_ev = MGMT_EV_DISCOVERING,
9524         .expect_alt_ev_param = start_discovery_le_evt,
9525         .expect_alt_ev_len = sizeof(start_discovery_le_evt),
9526 };
9527
9528 static const char stop_discovery_valid_ext_scan_disable[] = {
9529         0x00,
9530         0x00,
9531         0x00, 0x00,
9532         0x00, 0x00
9533 };
9534
9535 static const struct generic_data stop_discovery_le_ext_scan_disable = {
9536         .setup_settings = settings_powered_le,
9537         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
9538         .setup_send_param = start_discovery_bredrle_param,
9539         .setup_send_len = sizeof(start_discovery_bredrle_param),
9540         .send_opcode = MGMT_OP_STOP_DISCOVERY,
9541         .send_param = stop_discovery_bredrle_param,
9542         .send_len = sizeof(stop_discovery_bredrle_param),
9543         .expect_status = MGMT_STATUS_SUCCESS,
9544         .expect_param = stop_discovery_bredrle_param,
9545         .expect_len = sizeof(stop_discovery_bredrle_param),
9546         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_ENABLE,
9547         .expect_hci_param = stop_discovery_valid_ext_scan_disable,
9548         .expect_hci_len = sizeof(stop_discovery_valid_ext_scan_disable),
9549         .expect_alt_ev = MGMT_EV_DISCOVERING,
9550         .expect_alt_ev_param = stop_discovery_evt,
9551         .expect_alt_ev_len = sizeof(stop_discovery_evt),
9552 };
9553
9554 static const struct generic_data start_discovery_le_2m_scan_param = {
9555         .setup_settings = settings_powered_le,
9556         .setup_send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9557         .setup_send_param = set_phy_2m_param,
9558         .setup_send_len = sizeof(set_phy_2m_param),
9559         .send_opcode = MGMT_OP_START_DISCOVERY,
9560         .send_param = start_discovery_bredrle_param,
9561         .send_len = sizeof(start_discovery_bredrle_param),
9562         .expect_status = MGMT_STATUS_SUCCESS,
9563         .expect_param = start_discovery_bredrle_param,
9564         .expect_len = sizeof(start_discovery_bredrle_param),
9565         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_PARAMS,
9566         .expect_hci_param = start_discovery_valid_ext_scan_param,
9567         .expect_hci_len = sizeof(start_discovery_valid_ext_scan_param),
9568         .expect_alt_ev = MGMT_EV_DISCOVERING,
9569         .expect_alt_ev_param = start_discovery_evt,
9570         .expect_alt_ev_len = sizeof(start_discovery_evt),
9571 };
9572
9573 static const char start_discovery_valid_coded_scan_param[] = {
9574         0x01,                   /* Own Addr type*/
9575         0x00,                   /* Scan filter policy*/
9576         0x05,                   /*Phys - 1m & coded */
9577         0x01,                   /* Type */
9578         0x12, 0x00,             /* Interval */
9579         0x12, 0x00,             /* Window */
9580         0x01,                   /* Type */
9581         0x12, 0x00,             /* Interval */
9582         0x12, 0x00,             /* Window */
9583 };
9584
9585 static const struct generic_data start_discovery_le_coded_scan_param = {
9586         .setup_settings = settings_powered_le,
9587         .setup_send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9588         .setup_send_param = set_phy_coded_param,
9589         .setup_send_len = sizeof(set_phy_coded_param),
9590         .send_opcode = MGMT_OP_START_DISCOVERY,
9591         .send_param = start_discovery_bredrle_param,
9592         .send_len = sizeof(start_discovery_bredrle_param),
9593         .expect_status = MGMT_STATUS_SUCCESS,
9594         .expect_param = start_discovery_bredrle_param,
9595         .expect_len = sizeof(start_discovery_bredrle_param),
9596         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_PARAMS,
9597         .expect_hci_param = start_discovery_valid_coded_scan_param,
9598         .expect_hci_len = sizeof(start_discovery_valid_coded_scan_param),
9599         .expect_alt_ev = MGMT_EV_DISCOVERING,
9600         .expect_alt_ev_param = start_discovery_evt,
9601         .expect_alt_ev_len = sizeof(start_discovery_evt),
9602 };
9603
9604 static const char start_discovery_valid_1m_2m_coded_scan_param[] = {
9605         0x01,                   /* Own Addr type*/
9606         0x00,                   /* Scan filter policy*/
9607         0x05,                   /*Phys - 1m, coded */
9608         0x01,                   /* Type */
9609         0x12, 0x00,             /* Interval */
9610         0x12, 0x00,             /* Window */
9611         0x01,                   /* Type */
9612         0x12, 0x00,             /* Interval */
9613         0x12, 0x00,             /* Window */
9614 };
9615
9616 static const struct generic_data start_discovery_le_1m_coded_scan_param = {
9617         .setup_settings = settings_powered_le,
9618         .setup_send_opcode = MGMT_OP_SET_PHY_CONFIGURATION,
9619         .setup_send_param = set_phy_all_param,
9620         .setup_send_len = sizeof(set_phy_all_param),
9621         .send_opcode = MGMT_OP_START_DISCOVERY,
9622         .send_param = start_discovery_bredrle_param,
9623         .send_len = sizeof(start_discovery_bredrle_param),
9624         .expect_status = MGMT_STATUS_SUCCESS,
9625         .expect_param = start_discovery_bredrle_param,
9626         .expect_len = sizeof(start_discovery_bredrle_param),
9627         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_PARAMS,
9628         .expect_hci_param = start_discovery_valid_1m_2m_coded_scan_param,
9629         .expect_hci_len = sizeof(start_discovery_valid_1m_2m_coded_scan_param),
9630         .expect_alt_ev = MGMT_EV_DISCOVERING,
9631         .expect_alt_ev_param = start_discovery_evt,
9632         .expect_alt_ev_len = sizeof(start_discovery_evt),
9633 };
9634
9635
9636 static void set_phy_callback(uint8_t status, uint16_t length,
9637                                         const void *param, void *user_data)
9638 {
9639         if (status != MGMT_STATUS_SUCCESS) {
9640                 tester_setup_failed();
9641                 return;
9642         }
9643
9644         tester_print("Set PHY Success");
9645
9646         tester_setup_complete();
9647 }
9648
9649 static void setup_phy_configuration(const void *test_data)
9650 {
9651         struct test_data *data = tester_get_data();
9652         const struct generic_data *test = data->test_data;
9653         const void *send_param = test->setup_send_param;
9654         uint16_t send_len = test->setup_send_len;
9655         unsigned int id;
9656
9657         id = mgmt_register(data->mgmt, MGMT_EV_DISCOVERING, data->mgmt_index,
9658                            discovering_event, NULL, NULL);
9659         data->mgmt_discov_ev_id = id;
9660
9661         mgmt_send(data->mgmt, test->setup_send_opcode, data->mgmt_index,
9662                                 send_len, send_param, set_phy_callback,
9663                                 NULL, NULL);
9664 }
9665
9666 static const uint8_t get_dev_flags_param[] = {
9667         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9668         0x00,                                   /* Type */
9669 };
9670
9671 static const uint8_t get_dev_flags_rsp_param[] = {
9672         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9673         0x00,                                   /* Type */
9674         0x01, 0x00, 0x00, 0x00,                 /* Supported Flages */
9675         0x00, 0x00, 0x00, 0x00,                 /* Current Flages */
9676 };
9677
9678 static const struct generic_data get_dev_flags_success = {
9679         .send_opcode = MGMT_OP_GET_DEVICE_FLAGS,
9680         .send_param = get_dev_flags_param,
9681         .send_len = sizeof(get_dev_flags_param),
9682         .expect_status = MGMT_STATUS_SUCCESS,
9683         .expect_param = get_dev_flags_rsp_param,
9684         .expect_len = sizeof(get_dev_flags_rsp_param),
9685 };
9686
9687 static const uint8_t get_dev_flags_param_fail_1[] = {
9688         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9689 };
9690
9691 static const struct generic_data get_dev_flags_fail_1 = {
9692         .send_opcode = MGMT_OP_GET_DEVICE_FLAGS,
9693         .send_param = get_dev_flags_param_fail_1,
9694         .send_len = sizeof(get_dev_flags_param_fail_1),
9695         .expect_status = MGMT_STATUS_INVALID_PARAMS,
9696 };
9697
9698 static void setup_get_dev_flags(const void *test_data)
9699 {
9700         struct test_data *data = tester_get_data();
9701         unsigned char param[] = { 0x01 };
9702         const unsigned char *add_param;
9703         size_t add_param_len;
9704
9705         tester_print("Powering on controller (with added device)");
9706
9707         if (data->hciemu_type == HCIEMU_TYPE_LE) {
9708                 add_param = add_device_success_param_2;
9709                 add_param_len = sizeof(add_device_success_param_2);
9710         } else {
9711                 add_param = add_device_success_param_1;
9712                 add_param_len = sizeof(add_device_success_param_1);
9713         }
9714
9715         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
9716                         add_param_len, add_param, NULL, NULL, NULL);
9717
9718         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
9719                                         sizeof(param), param,
9720                                         setup_powered_callback, NULL, NULL);
9721 }
9722
9723 static const uint8_t set_dev_flags_param[] = {
9724         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9725         0x00,                                   /* Type */
9726         0x01, 0x00, 0x00, 0x00,                 /* Current Flages */
9727 };
9728
9729 static const uint8_t set_dev_flags_rsp_param[] = {
9730         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9731         0x00,                                   /* Type */
9732 };
9733
9734 static const uint8_t dev_flags_changed_param[] = {
9735         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9736         0x00,                                   /* Type */
9737         0x01, 0x00, 0x00, 0x00,                 /* Supported Flages */
9738         0x01, 0x00, 0x00, 0x00,                 /* Current Flages */
9739 };
9740
9741 static const struct generic_data set_dev_flags_success = {
9742         .send_opcode = MGMT_OP_SET_DEVICE_FLAGS,
9743         .send_param = set_dev_flags_param,
9744         .send_len = sizeof(set_dev_flags_param),
9745         .expect_status = MGMT_STATUS_SUCCESS,
9746         .expect_param = set_dev_flags_rsp_param,
9747         .expect_len = sizeof(set_dev_flags_rsp_param),
9748         .expect_alt_ev = MGMT_EV_DEVICE_FLAGS_CHANGED,
9749         .expect_alt_ev_param = dev_flags_changed_param,
9750         .expect_alt_ev_len = sizeof(dev_flags_changed_param),
9751 };
9752
9753 static const uint8_t set_dev_flags_param_fail_1[] = {
9754         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9755         0x00,                                   /* Type */
9756 };
9757
9758 static const struct generic_data set_dev_flags_fail_1 = {
9759         .send_opcode = MGMT_OP_SET_DEVICE_FLAGS,
9760         .send_param = set_dev_flags_param_fail_1,
9761         .send_len = sizeof(set_dev_flags_param_fail_1),
9762         .expect_status = MGMT_STATUS_INVALID_PARAMS,
9763 };
9764
9765 static const uint8_t set_dev_flags_param_fail_2[] = {
9766         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9767         0x00,                                   /* Type */
9768         0x03, 0x00, 0x00, 0x00,                 /* Current Flages */
9769 };
9770
9771 static const struct generic_data set_dev_flags_fail_2 = {
9772         .send_opcode = MGMT_OP_SET_DEVICE_FLAGS,
9773         .send_param = set_dev_flags_param_fail_2,
9774         .send_len = sizeof(set_dev_flags_param_fail_2),
9775         .expect_status = MGMT_STATUS_INVALID_PARAMS,
9776         .expect_param = set_dev_flags_rsp_param,
9777         .expect_len = sizeof(set_dev_flags_rsp_param),
9778 };
9779
9780 static const uint8_t set_dev_flags_param_fail_3[] = {
9781         0x11, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9782         0x00,                                   /* Type */
9783         0x01, 0x00, 0x00, 0x00,                 /* Current Flages */
9784 };
9785
9786 static const uint8_t set_dev_flags_rsp_param_fail_3[] = {
9787         0x11, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
9788         0x00,                                   /* Type */
9789 };
9790
9791 static const struct generic_data set_dev_flags_fail_3 = {
9792         .send_opcode = MGMT_OP_SET_DEVICE_FLAGS,
9793         .send_param = set_dev_flags_param_fail_3,
9794         .send_len = sizeof(set_dev_flags_param_fail_3),
9795         .expect_status = MGMT_STATUS_INVALID_PARAMS,
9796         .expect_param = set_dev_flags_rsp_param_fail_3,
9797         .expect_len = sizeof(set_dev_flags_rsp_param_fail_3),
9798 };
9799
9800 static const uint8_t read_exp_feat_param_success[] = {
9801         0x03, 0x00,                             /* Feature Count */
9802         0xd6, 0x49, 0xb0, 0xd1, 0x28, 0xeb,     /* UUID - Simultaneous */
9803         0x27, 0x92, 0x96, 0x46, 0xc0, 0x42,     /* Central Peripheral */
9804         0xb5, 0x10, 0x1b, 0x67,
9805         0x00, 0x00, 0x00, 0x00,                 /* Flags */
9806         0x04, 0x00, 0x13, 0xac, 0x42, 0x02,     /* UUID - LL Privacy */
9807         0xde, 0xb3, 0xea, 0x11, 0x73, 0xc2,
9808         0x48, 0xa1, 0xc0, 0x15,
9809         0x02, 0x00, 0x00, 0x00,                 /* Flags */
9810         0xaf, 0x29, 0xc6, 0x66, 0xac, 0x5f,     /* UUID - Codec Offload */
9811         0x1a, 0x88, 0xb9, 0x4f, 0x7f, 0xee,
9812         0xce, 0x5a, 0x69, 0xa6,
9813         0x00, 0x00, 0x00, 0x00                  /* Flags */
9814 };
9815
9816 static const struct generic_data read_exp_feat_success = {
9817         .send_opcode = MGMT_OP_READ_EXP_FEATURES_INFO,
9818         .expect_status = MGMT_STATUS_SUCCESS,
9819         .expect_param = read_exp_feat_param_success,
9820         .expect_len = sizeof(read_exp_feat_param_success),
9821 };
9822
9823
9824 static const uint8_t read_exp_feat_param_success_index_none[] = {
9825         0x01, 0x00,                             /* Feature Count */
9826         0x1c, 0xda, 0x47, 0x1c, 0x48, 0x6c,     /* UUID - Debug */
9827         0x01, 0xab, 0x9f, 0x46, 0xec, 0xb9,
9828         0x30, 0x25, 0x99, 0xd4,
9829         0x00, 0x00, 0x00, 0x00,                 /* Flags */
9830 };
9831
9832 static const struct generic_data read_exp_feat_success_index_none = {
9833         .send_index_none = true,
9834         .send_opcode = MGMT_OP_READ_EXP_FEATURES_INFO,
9835         .expect_status = MGMT_STATUS_SUCCESS,
9836         .expect_param = read_exp_feat_param_success_index_none,
9837         .expect_len = sizeof(read_exp_feat_param_success_index_none),
9838 };
9839
9840 static uint16_t settings_powered_le_privacy[] = { MGMT_OP_SET_LE,
9841                                                 MGMT_OP_SET_PRIVACY,
9842                                                 MGMT_OP_SET_POWERED, 0 };
9843
9844 static const uint8_t set_exp_feat_param_ll_privacy[] = {
9845         0x04, 0x00, 0x13, 0xac, 0x42, 0x02,     /* UUID - LL Privacy */
9846         0xde, 0xb3, 0xea, 0x11, 0x73, 0xc2,
9847         0x48, 0xa1, 0xc0, 0x15,
9848         0x01,                                   /* Action - enable */
9849 };
9850
9851 static const uint8_t set_exp_feat_rsp_param_ll_privacy[] = {
9852         0x04, 0x00, 0x13, 0xac, 0x42, 0x02,     /* UUID - LL Privacy */
9853         0xde, 0xb3, 0xea, 0x11, 0x73, 0xc2,
9854         0x48, 0xa1, 0xc0, 0x15,
9855         0x03, 0x00, 0x00, 0x00,                 /* Action - enable */
9856 };
9857
9858 static const uint8_t set_exp_feat_param_offload_codec[] = {
9859         0xaf, 0x29, 0xc6, 0x66, 0xac, 0x5f,     /* UUID - Codec Offload */
9860         0x1a, 0x88, 0xb9, 0x4f, 0x7f, 0xee,
9861         0xce, 0x5a, 0x69, 0xa6,
9862         0x01,                                   /* Action - enable */
9863 };
9864
9865 static const uint8_t set_exp_feat_rsp_param_offload_codec[] = {
9866         0xaf, 0x29, 0xc6, 0x66, 0xac, 0x5f,     /* UUID - Codec Offload */
9867         0x1a, 0x88, 0xb9, 0x4f, 0x7f, 0xee,
9868         0xce, 0x5a, 0x69, 0xa6,
9869         0x01, 0x00, 0x00, 0x00,                 /* Action - enable */
9870 };
9871
9872 static const struct generic_data set_exp_feat_enable_ll_privacy = {
9873         .send_opcode = MGMT_OP_SET_EXP_FEATURE,
9874         .send_param = set_exp_feat_param_ll_privacy,
9875         .send_len = sizeof(set_exp_feat_param_ll_privacy),
9876         .expect_status = MGMT_STATUS_SUCCESS,
9877         .expect_param = set_exp_feat_rsp_param_ll_privacy,
9878         .expect_len = sizeof(set_exp_feat_rsp_param_ll_privacy),
9879         .expect_alt_ev = MGMT_EV_EXP_FEATURE_CHANGE,
9880         .expect_alt_ev_len = sizeof(struct mgmt_ev_exp_feature_changed),
9881 };
9882
9883 static void read_exp_feature_callback(uint8_t status, uint16_t length,
9884                                         const void *param, void *user_data)
9885 {
9886         if (status != MGMT_STATUS_SUCCESS) {
9887                 tester_setup_failed();
9888                 return;
9889         }
9890
9891         tester_print("Received Read Experimental Features Info");
9892
9893         tester_setup_complete();
9894 }
9895
9896 static void setup_set_exp_feature_alt(const void *test_data)
9897 {
9898         struct test_data *data = tester_get_data();
9899
9900         /* Send the Read Experiemental Features Information command to receive
9901          * the Experiemental Feature Changed event
9902          */
9903         mgmt_send(data->mgmt_alt, MGMT_OP_READ_EXP_FEATURES_INFO,
9904                         data->mgmt_index, 0, NULL,
9905                         read_exp_feature_callback, NULL, NULL);
9906 }
9907
9908 static const struct generic_data set_exp_feat_offload_codec = {
9909         .send_opcode = MGMT_OP_SET_EXP_FEATURE,
9910         .send_param = set_exp_feat_param_offload_codec,
9911         .send_len = sizeof(set_exp_feat_param_offload_codec),
9912         .expect_status = MGMT_STATUS_SUCCESS,
9913         .expect_param = set_exp_feat_rsp_param_offload_codec,
9914         .expect_len = sizeof(set_exp_feat_rsp_param_offload_codec),
9915         .expect_alt_ev = MGMT_EV_EXP_FEATURE_CHANGE,
9916         .expect_alt_ev_len = sizeof(struct mgmt_ev_exp_feature_changed),
9917 };
9918
9919 static const uint8_t set_exp_feat_param_disable[17] = { 0x00 };
9920 static const uint8_t set_exp_feat_rsp_param_disable[20] = { 0x00 };
9921
9922 static const struct generic_data set_exp_feat_disable = {
9923         .send_opcode = MGMT_OP_SET_EXP_FEATURE,
9924         .send_param = set_exp_feat_param_disable,
9925         .send_len = sizeof(set_exp_feat_param_disable),
9926         .expect_status = MGMT_STATUS_SUCCESS,
9927         .expect_param = set_exp_feat_rsp_param_disable,
9928         .expect_len = sizeof(set_exp_feat_rsp_param_disable),
9929 };
9930
9931 static const struct generic_data set_exp_feat_rejected = {
9932         .setup_settings = settings_powered_le_privacy,
9933         .send_opcode = MGMT_OP_SET_EXP_FEATURE,
9934         .send_param = set_exp_feat_param_ll_privacy,
9935         .send_len = sizeof(set_exp_feat_param_ll_privacy),
9936         .expect_status = MGMT_STATUS_REJECTED,
9937 };
9938
9939 static const uint8_t set_exp_feat_param_invalid[] = {
9940         0x04, 0x00, 0x13, 0xac, 0x42, 0x02,     /* UUID - LL Privacy */
9941         0xde, 0xb3, 0xea, 0x11, 0x73, 0xc2,
9942         0x48, 0xa1, 0xc0, 0x15,
9943         0xff,                                   /* Action - invalid */
9944 };
9945
9946 static const struct generic_data set_exp_feat_invalid = {
9947         .send_opcode = MGMT_OP_SET_EXP_FEATURE,
9948         .send_param = set_exp_feat_param_invalid,
9949         .send_len = sizeof(set_exp_feat_param_invalid),
9950         .expect_status = MGMT_STATUS_INVALID_PARAMS,
9951 };
9952
9953 static const uint8_t set_exp_feat_param_unknown[] = {
9954         0xff, 0xff, 0xff, 0xff, 0xff, 0xff,     /* UUID - Unknown */
9955         0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
9956         0xff, 0xff, 0xff, 0xff,
9957         0x01,                                   /* Action - enable */
9958 };
9959
9960 static const struct generic_data set_exp_feat_unknown = {
9961         .send_opcode = MGMT_OP_SET_EXP_FEATURE,
9962         .send_param = set_exp_feat_param_unknown,
9963         .send_len = sizeof(set_exp_feat_param_unknown),
9964         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
9965 };
9966
9967 static const uint8_t add_device_le_public_param_1[] = {
9968         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* BDADDR */
9969         0x01,                                   /* Type - LE Public */
9970         0x02,                                   /* Action - Auto-Connect */
9971 };
9972
9973 static const uint8_t add_device_rsp_le_public[] =  {
9974         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* BDADDR */
9975         0x01,                                   /* Type - LE Public */
9976 };
9977 static const char load_irks_le_public_param_1[] = {
9978         0x01, 0x00,                                     /* Key Count */
9979         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,             /* Key 1 - BDADDR */
9980         0x01,                                           /* Key 1 - Type */
9981         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 1 - Value */
9982         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
9983 };
9984
9985 static const uint8_t add_device_le_public_param_2[] = {
9986         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,     /* BDADDR */
9987         0x01,                                   /* Type - LE Public */
9988         0x00,                                   /* Action - Background scan */
9989 };
9990
9991 static const uint8_t add_device_rsp_le_public_2[] =  {
9992         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,     /* BDADDR */
9993         0x01,                                   /* Type - LE Public */
9994 };
9995
9996 static const uint8_t add_device_le_public_param_3[] = {
9997         0x33, 0x33, 0x33, 0x44, 0x55, 0x66,     /* BDADDR */
9998         0x01,                                   /* Type - LE Public */
9999         0x00,                                   /* Action - Background scan */
10000 };
10001
10002 static const uint8_t add_device_rsp_le_public_3[] =  {
10003         0x33, 0x33, 0x33, 0x44, 0x55, 0x66,     /* BDADDR */
10004         0x01,                                   /* Type - LE Public */
10005 };
10006
10007 static const uint8_t add_device_le_public_param_4[] = {
10008         0x44, 0x44, 0x44, 0x44, 0x55, 0x66,     /* BDADDR */
10009         0x01,                                   /* Type - LE Public */
10010         0x00,                                   /* Action - Background scan */
10011 };
10012
10013 static const uint8_t add_device_rsp_le_public_4[] =  {
10014         0x44, 0x44, 0x44, 0x44, 0x55, 0x66,     /* BDADDR */
10015         0x01,                                   /* Type - LE Public */
10016 };
10017
10018 static const char load_irks_2_devices_param[] = {
10019         0x02, 0x00,                                     /* Key Count */
10020         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,             /* Key 1 - BDADDR */
10021         0x01,                                           /* Key 1 - Type */
10022         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 1 - Value */
10023         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10024         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,             /* Key 2 - BDADDR */
10025         0x01,                                           /* Key 2 - Type */
10026         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 2 - Value */
10027         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88
10028 };
10029
10030 static const char load_irks_3_devices_param[] = {
10031         0x03, 0x00,                                     /* Key Count */
10032         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,             /* Key 1 - BDADDR */
10033         0x01,                                           /* Key 1 - Type */
10034         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 1 - Value */
10035         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10036         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,             /* Key 2 - BDADDR */
10037         0x01,                                           /* Key 2 - Type */
10038         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 2 - Value */
10039         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10040         0x33, 0x33, 0x33, 0x44, 0x55, 0x66,             /* Key 3 - BDADDR */
10041         0x01,                                           /* Key 3 - Type */
10042         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 3 - Value */
10043         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10044 };
10045
10046 static const char load_irks_4_devices_param[] = {
10047         0x04, 0x00,                                     /* Key Count */
10048         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,             /* Key 1 - BDADDR */
10049         0x01,                                           /* Key 1 - Type */
10050         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 1 - Value */
10051         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10052         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,             /* Key 2 - BDADDR */
10053         0x01,                                           /* Key 2 - Type */
10054         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 2 - Value */
10055         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10056         0x33, 0x33, 0x33, 0x44, 0x55, 0x66,             /* Key 3 - BDADDR */
10057         0x01,                                           /* Key 3 - Type */
10058         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 3 - Value */
10059         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10060         0x44, 0x44, 0x44, 0x44, 0x55, 0x66,             /* Key 4 - BDADDR */
10061         0x01,                                           /* Key 4 - Type */
10062         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Key 4 - Value */
10063         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10064 };
10065
10066 static const uint8_t le_add_to_accept_list_param[] = {
10067         0x00,                                   /* Type */
10068         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* Address */
10069 };
10070
10071 static const uint8_t le_add_to_white_list_param_2[] = {
10072         0x00,                                   /* Type */
10073         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,     /* Address */
10074 };
10075
10076 static const uint8_t le_add_to_white_list_param_3[] = {
10077         0x00,                                   /* Type */
10078         0x33, 0x33, 0x33, 0x44, 0x55, 0x66,     /* Address */
10079 };
10080
10081 static const uint8_t le_add_to_resolv_list_param[] = {
10082         0x00,                                           /* Type */
10083         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,             /* BDADDR */
10084         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Peer IRK */
10085         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10086         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* Local IRK */
10087         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
10088 };
10089
10090 static const uint8_t le_add_to_resolv_list_param_2[] = {
10091         0x00,                                           /* Type */
10092         0x11, 0x22, 0x33, 0x44, 0x55, 0x66,             /* BDADDR */
10093         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Peer IRK */
10094         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10095         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* Local IRK */
10096         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
10097 };
10098
10099 static const uint8_t le_add_to_resolv_list_param_4[] = {
10100         0x00,                                           /* Type */
10101         0x44, 0x44, 0x44, 0x44, 0x55, 0x66,             /* BDADDR */
10102         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, /* Peer IRK */
10103         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
10104         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* Local IRK */
10105         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
10106 };
10107
10108 static const char set_resolv_off_param[] = { 0x00 };
10109 static const char set_resolv_on_param[] = { 0x01 };
10110
10111 static const struct generic_data ll_privacy_add_device_1 = {
10112         .setup_settings = settings_powered_le,
10113         .send_opcode = MGMT_OP_ADD_DEVICE,
10114         .send_param = add_device_le_public_param_1,
10115         .send_len = sizeof(add_device_le_public_param_1),
10116         .expect_param = add_device_rsp_le,
10117         .expect_len = sizeof(add_device_rsp_le),
10118         .expect_status = MGMT_STATUS_SUCCESS,
10119         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10120         .expect_alt_ev_param = add_device_le_public_param_1,
10121         .expect_alt_ev_len = sizeof(add_device_le_public_param_1),
10122         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
10123         .expect_hci_param = le_add_to_accept_list_param,
10124         .expect_hci_len = sizeof(le_add_to_accept_list_param),
10125 };
10126
10127 static uint16_t settings_le_privacy_ll_privacy[] = { MGMT_OP_SET_LE,
10128                                         MGMT_OP_SET_PRIVACY,
10129                                         MGMT_OP_SET_EXP_FEATURE, 0 };
10130
10131 static const struct generic_data ll_privacy_add_device_2 = {
10132         .setup_settings = settings_le_privacy_ll_privacy,
10133         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10134         .send_opcode = MGMT_OP_ADD_DEVICE,
10135         .send_param = add_device_le_public_param_1,
10136         .send_len = sizeof(add_device_le_public_param_1),
10137         .expect_param = add_device_rsp_le_public,
10138         .expect_len = sizeof(add_device_rsp_le_public),
10139         .expect_status = MGMT_STATUS_SUCCESS,
10140         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10141         .expect_alt_ev_param = add_device_le_public_param_1,
10142         .expect_alt_ev_len = sizeof(add_device_le_public_param_1),
10143         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_RESOLV_LIST,
10144         .expect_hci_param = le_add_to_resolv_list_param,
10145         .expect_hci_len = sizeof(le_add_to_resolv_list_param),
10146 };
10147
10148 static const struct hci_cmd_data ll_privacy_add_device_3_hci_list[] = {
10149         {
10150                 .opcode = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10151                 .param = set_resolv_off_param,
10152                 .len = sizeof(set_resolv_off_param),
10153         },
10154         {
10155                 .opcode = BT_HCI_CMD_LE_ADD_TO_RESOLV_LIST,
10156                 .param = le_add_to_resolv_list_param,
10157                 .len = sizeof(le_add_to_resolv_list_param),
10158         },
10159         {
10160                 .opcode = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
10161                 .param = le_add_to_accept_list_param,
10162                 .len = sizeof(le_add_to_accept_list_param),
10163         },
10164         {
10165                 .opcode = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10166                 .param = set_resolv_on_param,
10167                 .len = sizeof(set_resolv_on_param),
10168         },
10169 };
10170
10171 static const struct generic_data ll_privacy_add_device_3 = {
10172         .setup_settings = settings_le_privacy_ll_privacy,
10173         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10174         .send_opcode = MGMT_OP_ADD_DEVICE,
10175         .send_param = add_device_le_public_param_1,
10176         .send_len = sizeof(add_device_le_public_param_1),
10177         .expect_param = add_device_rsp_le,
10178         .expect_len = sizeof(add_device_rsp_le),
10179         .expect_status = MGMT_STATUS_SUCCESS,
10180         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10181         .expect_alt_ev_param = add_device_le_public_param_1,
10182         .expect_alt_ev_len = sizeof(add_device_le_public_param_1),
10183         .expect_hci_list = ll_privacy_add_device_3_hci_list,
10184 };
10185
10186 static const struct generic_data ll_privacy_add_device_4 = {
10187         .setup_settings = settings_le_privacy_ll_privacy,
10188         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10189         .send_opcode = MGMT_OP_ADD_DEVICE,
10190         .send_param = add_device_le_public_param_2,
10191         .send_len = sizeof(add_device_le_public_param_2),
10192         .expect_param = add_device_rsp_le_public_2,
10193         .expect_len = sizeof(add_device_rsp_le_public_2),
10194         .expect_status = MGMT_STATUS_SUCCESS,
10195         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10196         .expect_alt_ev_param = add_device_le_public_param_2,
10197         .expect_alt_ev_len = sizeof(add_device_le_public_param_2),
10198         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
10199         .expect_hci_param = le_add_to_white_list_param_2,
10200         .expect_hci_len = sizeof(le_add_to_white_list_param_2),
10201 };
10202
10203 static const struct generic_data ll_privacy_add_device_5 = {
10204         .setup_settings = settings_le_privacy_ll_privacy,
10205         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10206         .send_opcode = MGMT_OP_ADD_DEVICE,
10207         .send_param = add_device_le_public_param_2,
10208         .send_len = sizeof(add_device_le_public_param_2),
10209         .expect_param = add_device_rsp_le_public_2,
10210         .expect_len = sizeof(add_device_rsp_le_public_2),
10211         .expect_status = MGMT_STATUS_SUCCESS,
10212         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10213         .expect_alt_ev_param = add_device_le_public_param_2,
10214         .expect_alt_ev_len = sizeof(add_device_le_public_param_2),
10215         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_RESOLV_LIST,
10216         .expect_hci_param = le_add_to_resolv_list_param_2,
10217         .expect_hci_len = sizeof(le_add_to_resolv_list_param_2),
10218 };
10219
10220 static const struct generic_data ll_privacy_add_device_6 = {
10221         .setup_settings = settings_le_privacy_ll_privacy,
10222         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10223         .send_opcode = MGMT_OP_ADD_DEVICE,
10224         .send_param = add_device_le_public_param_4,
10225         .send_len = sizeof(add_device_le_public_param_4),
10226         .expect_param = add_device_rsp_le_public_4,
10227         .expect_len = sizeof(add_device_rsp_le_public_4),
10228         .expect_status = MGMT_STATUS_SUCCESS,
10229         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10230         .expect_alt_ev_param = add_device_le_public_param_4,
10231         .expect_alt_ev_len = sizeof(add_device_le_public_param_4),
10232         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_RESOLV_LIST,
10233         .expect_hci_param = le_add_to_resolv_list_param_4,
10234         .expect_hci_len = sizeof(le_add_to_resolv_list_param_4),
10235 };
10236
10237 static const struct generic_data ll_privacy_add_device_7 = {
10238         .setup_settings = settings_le_privacy_ll_privacy,
10239         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10240         .send_opcode = MGMT_OP_ADD_DEVICE,
10241         .send_param = add_device_le_public_param_3,
10242         .send_len = sizeof(add_device_le_public_param_3),
10243         .expect_param = add_device_rsp_le_public_3,
10244         .expect_len = sizeof(add_device_rsp_le_public_3),
10245         .expect_status = MGMT_STATUS_SUCCESS,
10246         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10247         .expect_alt_ev_param = add_device_le_public_param_3,
10248         .expect_alt_ev_len = sizeof(add_device_le_public_param_3),
10249         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
10250         .expect_hci_param = le_add_to_white_list_param_3,
10251         .expect_hci_len = sizeof(le_add_to_white_list_param_3),
10252 };
10253
10254 static const char set_ext_adv_disable[] = {
10255         0x00, 0x00,
10256 };
10257
10258 static const struct generic_data ll_privacy_add_device_8 = {
10259         .setup_settings = settings_le_privacy_ll_privacy,
10260         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10261         .send_opcode = MGMT_OP_ADD_DEVICE,
10262         .send_param = add_device_le_public_param_3,
10263         .send_len = sizeof(add_device_le_public_param_3),
10264         .expect_param = add_device_rsp_le_public_3,
10265         .expect_len = sizeof(add_device_rsp_le_public_3),
10266         .expect_status = MGMT_STATUS_SUCCESS,
10267         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10268         .expect_alt_ev_param = add_device_le_public_param_3,
10269         .expect_alt_ev_len = sizeof(add_device_le_public_param_3),
10270         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
10271         .expect_hci_param = set_ext_adv_disable,
10272         .expect_hci_len = sizeof(set_ext_adv_disable),
10273 };
10274
10275 static const struct hci_cmd_data ll_privacy_add_device_9_hci_list[] = {
10276         {
10277                 .opcode = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
10278                 .len = sizeof(set_ext_adv_disable),
10279                 .param = set_ext_adv_disable,
10280         },
10281         {
10282                 .opcode = BT_HCI_CMD_LE_ADD_TO_RESOLV_LIST,
10283                 .len = sizeof(le_add_to_resolv_list_param),
10284                 .param = le_add_to_resolv_list_param
10285         },
10286 };
10287
10288 static const struct generic_data ll_privacy_add_device_9 = {
10289         .setup_settings = settings_le_privacy_ll_privacy,
10290         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10291         .send_opcode = MGMT_OP_ADD_DEVICE,
10292         .send_param = add_device_le_public_param_1,
10293         .send_len = sizeof(add_device_le_public_param_1),
10294         .expect_param = add_device_rsp_le_public,
10295         .expect_len = sizeof(add_device_rsp_le_public),
10296         .expect_status = MGMT_STATUS_SUCCESS,
10297         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
10298         .expect_alt_ev_param = add_device_le_public_param_1,
10299         .expect_alt_ev_len = sizeof(add_device_le_public_param_1),
10300         .expect_hci_list = ll_privacy_add_device_9_hci_list,
10301 };
10302
10303 static const struct generic_data ll_privacy_remove_device_1 = {
10304         .setup_settings = settings_le_privacy_ll_privacy,
10305         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10306         .send_opcode = MGMT_OP_REMOVE_DEVICE,
10307         .send_param = remove_device_param_2,
10308         .send_len = sizeof(remove_device_param_2),
10309         .expect_param = remove_device_param_2,
10310         .expect_len = sizeof(remove_device_param_2),
10311         .expect_status = MGMT_STATUS_SUCCESS,
10312         .expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST,
10313         .expect_hci_param = le_add_to_accept_list_param,
10314         .expect_hci_len = sizeof(le_add_to_accept_list_param),
10315         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
10316         .expect_alt_ev_param = remove_device_param_2,
10317         .expect_alt_ev_len = sizeof(remove_device_param_2),
10318 };
10319
10320 static const struct generic_data ll_privacy_remove_device_2 = {
10321         .setup_settings = settings_le_privacy_ll_privacy,
10322         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10323         .send_opcode = MGMT_OP_REMOVE_DEVICE,
10324         .send_param = remove_device_param_2,
10325         .send_len = sizeof(remove_device_param_2),
10326         .expect_param = remove_device_param_2,
10327         .expect_len = sizeof(remove_device_param_2),
10328         .expect_status = MGMT_STATUS_SUCCESS,
10329         .expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_RESOLV_LIST,
10330         .expect_hci_param = le_add_to_accept_list_param,
10331         .expect_hci_len = sizeof(le_add_to_accept_list_param),
10332         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
10333         .expect_alt_ev_param = remove_device_param_2,
10334         .expect_alt_ev_len = sizeof(remove_device_param_2),
10335 };
10336
10337 static const struct generic_data ll_privacy_remove_device_3 = {
10338         .setup_settings = settings_le_privacy_ll_privacy,
10339         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10340         .send_opcode = MGMT_OP_REMOVE_DEVICE,
10341         .send_param = remove_device_param_2,
10342         .send_len = sizeof(remove_device_param_2),
10343         .expect_param = remove_device_param_2,
10344         .expect_len = sizeof(remove_device_param_2),
10345         .expect_status = MGMT_STATUS_SUCCESS,
10346         .expect_hci_command = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10347         .expect_hci_param = set_resolv_off_param,
10348         .expect_hci_len = sizeof(set_resolv_off_param),
10349         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
10350         .expect_alt_ev_param = remove_device_param_2,
10351         .expect_alt_ev_len = sizeof(remove_device_param_2),
10352 };
10353
10354 static const struct generic_data ll_privacy_remove_device_4 = {
10355         .setup_settings = settings_le_privacy_ll_privacy,
10356         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10357         .send_opcode = MGMT_OP_REMOVE_DEVICE,
10358         .send_param = remove_device_param_2,
10359         .send_len = sizeof(remove_device_param_2),
10360         .expect_param = remove_device_param_2,
10361         .expect_len = sizeof(remove_device_param_2),
10362         .expect_status = MGMT_STATUS_SUCCESS,
10363         .expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_RESOLV_LIST,
10364         .expect_hci_param = le_add_to_accept_list_param,
10365         .expect_hci_len = sizeof(le_add_to_accept_list_param),
10366         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
10367         .expect_alt_ev_param = remove_device_param_2,
10368         .expect_alt_ev_len = sizeof(remove_device_param_2),
10369 };
10370
10371 static const struct generic_data ll_privacy_remove_device_5 = {
10372         .setup_settings = settings_le_privacy_ll_privacy,
10373         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10374         .send_opcode = MGMT_OP_REMOVE_DEVICE,
10375         .send_param = remove_device_param_2,
10376         .send_len = sizeof(remove_device_param_2),
10377         .expect_param = remove_device_param_2,
10378         .expect_len = sizeof(remove_device_param_2),
10379         .expect_status = MGMT_STATUS_SUCCESS,
10380         .expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_RESOLV_LIST,
10381         .expect_hci_param = le_add_to_accept_list_param,
10382         .expect_hci_len = sizeof(le_add_to_accept_list_param),
10383         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
10384         .expect_alt_ev_param = remove_device_param_2,
10385         .expect_alt_ev_len = sizeof(remove_device_param_2),
10386 };
10387
10388 static const struct generic_data ll_privacy_start_discovery_ll_privacy_1 = {
10389         .setup_settings = settings_le_privacy_ll_privacy,
10390         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10391         .setup_expect_hci_command = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10392         .setup_expect_hci_param = set_resolv_on_param,
10393         .setup_expect_hci_len = sizeof(set_resolv_on_param),
10394         .send_opcode = MGMT_OP_START_DISCOVERY,
10395         .send_param = start_discovery_le_param,
10396         .send_len = sizeof(start_discovery_le_param),
10397         .expect_status = MGMT_STATUS_SUCCESS,
10398         .expect_param = start_discovery_le_param,
10399         .expect_len = sizeof(start_discovery_le_param),
10400         .expect_hci_command = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10401         .expect_hci_param = set_resolv_off_param,
10402         .expect_hci_len = sizeof(set_resolv_off_param),
10403 };
10404
10405 static const struct generic_data ll_privacy_start_discovery_ll_privacy_2 = {
10406         .setup_settings = settings_le_privacy_ll_privacy,
10407         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10408         .setup_expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_RESOLV_LIST,
10409         .setup_expect_hci_param = le_add_to_accept_list_param,
10410         .setup_expect_hci_len = sizeof(le_add_to_accept_list_param),
10411         .send_opcode = MGMT_OP_START_DISCOVERY,
10412         .send_param = start_discovery_le_param,
10413         .send_len = sizeof(start_discovery_le_param),
10414         .expect_status = MGMT_STATUS_SUCCESS,
10415         .expect_param = start_discovery_le_param,
10416         .expect_len = sizeof(start_discovery_le_param),
10417         .expect_hci_command = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10418         .expect_hci_param = set_resolv_off_param,
10419         .expect_hci_len = sizeof(set_resolv_off_param),
10420         .expect_alt_ev = MGMT_EV_DISCOVERING,
10421         .expect_alt_ev_param = start_discovery_le_evt,
10422         .expect_alt_ev_len = sizeof(start_discovery_le_evt),
10423 };
10424
10425 static const struct generic_data ll_privacy_advertising_1 = {
10426         .setup_settings = settings_le_privacy_ll_privacy,
10427         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10428         .send_opcode = MGMT_OP_SET_ADVERTISING,
10429         .send_param = set_adv_on_param2,
10430         .send_len = sizeof(set_adv_on_param2),
10431         .expect_status = MGMT_STATUS_SUCCESS,
10432         .expect_ignore_param = true,
10433 };
10434
10435 static const struct generic_data ll_privacy_acceptor_1 = {
10436         .setup_settings = settings_le_privacy_ll_privacy,
10437         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10438         .io_cap = 0x04, /* KeyboardDisplay */
10439         .client_io_cap = 0x04, /* KeyboardDisplay */
10440         .client_auth_req = 0x05, /* Bonding - MITM */
10441         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
10442         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
10443         .verify_alt_ev_func = verify_ltk,
10444 };
10445
10446 static const struct generic_data ll_privacy_acceptor_2 = {
10447         .setup_settings = settings_le_privacy_ll_privacy,
10448         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10449         .io_cap = 0x04, /* KeyboardDisplay */
10450         .client_io_cap = 0x04, /* KeyboardDisplay */
10451         .just_works = true,
10452         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
10453         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
10454         .verify_alt_ev_func = verify_ltk,
10455 };
10456
10457 static const uint8_t unpair_client_1[] = {
10458         0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,     /* Address */
10459         0x01,                                   /* Type */
10460         0x01,                                   /* Disconnect */
10461 };
10462
10463 static const uint8_t unpair_resp_param_1[] = {
10464         0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,     /* Address */
10465         0x01,                                   /* Type */
10466 };
10467
10468 static const uint8_t add_paired_client_1[] = {
10469         0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,     /* Address */
10470         0x01,                                   /* Type */
10471         0x00,
10472 };
10473
10474 static const uint8_t remove_paired_device_1[] = {
10475         0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,     /* Address */
10476         0x01,                                   /* Type */
10477 };
10478
10479 static const uint8_t add_to_al_client[] = {
10480         0x00,                                   /* Address Type */
10481         0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,     /* Address */
10482 };
10483
10484 static uint16_t settings_powered_le_sc_bondable_privacy_ll_privacy[] = {
10485                                                 MGMT_OP_SET_LE,
10486                                                 MGMT_OP_SET_SSP,
10487                                                 MGMT_OP_SET_BONDABLE,
10488                                                 MGMT_OP_SET_SECURE_CONN,
10489                                                 MGMT_OP_SET_PRIVACY,
10490                                                 MGMT_OP_SET_EXP_FEATURE,
10491                                                 MGMT_OP_SET_POWERED, 0 };
10492
10493 static const struct generic_data ll_privacy_pair_1 = {
10494         .setup_settings = settings_powered_le_sc_bondable_privacy_ll_privacy,
10495         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10496         .send_opcode = MGMT_OP_PAIR_DEVICE,
10497         .send_func = pair_device_send_param_func,
10498         .addr_type_avail = true,
10499         .addr_type = 0x01,
10500         .client_enable_sc = true,
10501         .client_enable_ssp = true,
10502         .client_enable_adv = true,
10503         .expect_sc_key = true,
10504         .io_cap = 0x02, /* KeyboardOnly */
10505         .client_io_cap = 0x02, /* KeyboardOnly */
10506         .client_auth_req = 0x05, /* Bonding - MITM */
10507         .expect_status = MGMT_STATUS_SUCCESS,
10508         .expect_func = pair_device_expect_param_func,
10509         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
10510         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
10511         .verify_alt_ev_func = verify_ltk,
10512 };
10513
10514 static const struct generic_data ll_privacy_pair_2 = {
10515         .setup_settings = settings_powered_le_sc_bondable_privacy_ll_privacy,
10516         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10517         .send_opcode = MGMT_OP_PAIR_DEVICE,
10518         .send_func = pair_device_send_param_func,
10519         .addr_type_avail = true,
10520         .addr_type = 0x01,
10521         .client_enable_sc = true,
10522         .client_enable_ssp = true,
10523         .client_enable_adv = true,
10524         .expect_sc_key = true,
10525         .io_cap = 0x02, /* KeyboardOnly */
10526         .client_io_cap = 0x02, /* KeyboardOnly */
10527         .client_auth_req = 0x05, /* Bonding - MITM */
10528         .expect_status = MGMT_STATUS_SUCCESS,
10529         .expect_func = pair_device_expect_param_func,
10530         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
10531         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
10532         .verify_alt_ev_func = verify_ltk,
10533         .expect_hci_command = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
10534         .expect_hci_param = add_to_al_client,
10535         .expect_hci_len = sizeof(add_to_al_client),
10536 };
10537
10538 static const struct generic_data ll_privacy_unpair_1 = {
10539         .setup_settings = settings_powered_le_sc_bondable_privacy_ll_privacy,
10540         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10541         .send_opcode = MGMT_OP_PAIR_DEVICE,
10542         .send_func = pair_device_send_param_func,
10543         .addr_type_avail = true,
10544         .addr_type = 0x01,
10545         .client_enable_sc = true,
10546         .client_enable_ssp = true,
10547         .client_enable_adv = true,
10548         .expect_sc_key = true,
10549         .io_cap = 0x02, /* KeyboardOnly */
10550         .client_io_cap = 0x02, /* KeyboardOnly */
10551         .expect_status = MGMT_STATUS_SUCCESS,
10552         .expect_func = pair_device_expect_param_func,
10553         .expect_alt_ev = MGMT_EV_DEVICE_UNPAIRED,
10554         .expect_alt_ev_param = unpair_resp_param_1,
10555         .expect_alt_ev_len = sizeof(unpair_resp_param_1),
10556 };
10557
10558 static const struct generic_data ll_privacy_unpair_2 = {
10559         .setup_settings = settings_powered_le_sc_bondable_privacy_ll_privacy,
10560         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10561         .send_opcode = MGMT_OP_PAIR_DEVICE,
10562         .send_func = pair_device_send_param_func,
10563         .addr_type_avail = true,
10564         .addr_type = 0x01,
10565         .client_enable_sc = true,
10566         .client_enable_ssp = true,
10567         .client_enable_adv = true,
10568         .expect_sc_key = true,
10569         .io_cap = 0x02, /* KeyboardOnly */
10570         .client_io_cap = 0x02, /* KeyboardOnly */
10571         .expect_status = MGMT_STATUS_SUCCESS,
10572         .expect_func = pair_device_expect_param_func,
10573         .expect_alt_ev = MGMT_EV_DEVICE_UNPAIRED,
10574         .expect_alt_ev_param = unpair_resp_param_1,
10575         .expect_alt_ev_len = sizeof(unpair_resp_param_1),
10576         .expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST,
10577         .expect_hci_param = add_to_al_client,
10578         .expect_hci_len = sizeof(add_to_al_client),
10579 };
10580
10581 static const uint8_t set_device_flags_param_1[] = {
10582         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* BDADDR */
10583         0x01,                                   /* Type - LE Public */
10584         0x02, 0x00, 0x00, 0x00                  /* Flags - Device Privacy */
10585 };
10586
10587 static const uint8_t set_device_flags_rsp[] =  {
10588         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* BDADDR */
10589         0x01                                    /* Type - LE Public */
10590 };
10591
10592 static const uint8_t le_set_priv_mode_param[] = {
10593         0x00,                                   /* Type */
10594         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* BDADDR */
10595         0x01                                    /* Privacy Mode */
10596 };
10597
10598 static const struct hci_cmd_data ll_privacy_set_device_flags_1_hci_list[] = {
10599         {
10600                 .opcode = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10601                 .param = set_resolv_off_param,
10602                 .len = sizeof(set_resolv_off_param),
10603         },
10604         {
10605                 .opcode = BT_HCI_CMD_LE_SET_PRIV_MODE,
10606                 .param = le_set_priv_mode_param,
10607                 .len = sizeof(le_set_priv_mode_param),
10608         },
10609         {
10610                 .opcode = BT_HCI_CMD_LE_SET_RESOLV_ENABLE,
10611                 .param = set_resolv_on_param,
10612                 .len = sizeof(set_resolv_on_param),
10613         },
10614 };
10615
10616 static const uint8_t device_flags_changed_params_1[] = {
10617         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,     /* BDADDR */
10618         0x01,                                   /* Type - LE Public */
10619         0x03, 0x00, 0x00, 0x00,                 /* Supported Flags */
10620         0x02, 0x00, 0x00, 0x00                  /* Current Flags */
10621 };
10622
10623 static const struct generic_data ll_privacy_set_device_flag_1 = {
10624         .setup_settings = settings_le_privacy_ll_privacy,
10625         .setup_exp_feat_param = set_exp_feat_param_ll_privacy,
10626         .send_opcode = MGMT_OP_SET_DEVICE_FLAGS,
10627         .send_param = set_device_flags_param_1,
10628         .send_len = sizeof(set_device_flags_param_1),
10629         .expect_param = set_device_flags_rsp,
10630         .expect_len = sizeof(set_device_flags_rsp),
10631         .expect_status = MGMT_STATUS_SUCCESS,
10632         .expect_alt_ev = MGMT_EV_DEVICE_FLAGS_CHANGED,
10633         .expect_alt_ev_param = device_flags_changed_params_1,
10634         .expect_alt_ev_len = sizeof(device_flags_changed_params_1),
10635         .expect_hci_list = ll_privacy_set_device_flags_1_hci_list,
10636 };
10637
10638 static void setup_load_irks_callback(uint8_t status, uint16_t length,
10639                                         const void *param, void *user_data)
10640 {
10641         if (status != MGMT_STATUS_SUCCESS) {
10642                 tester_setup_failed();
10643                 return;
10644         }
10645
10646         tester_print("Load IRK completed");
10647 }
10648
10649 static void setup_add_device_callback(uint8_t status, uint16_t length,
10650                                         const void *param, void *user_data)
10651 {
10652         if (status != MGMT_STATUS_SUCCESS) {
10653                 tester_setup_failed();
10654                 return;
10655         }
10656
10657         tester_print("New Device is Added");
10658 }
10659
10660 static void setup_remove_device_callback(uint8_t status, uint16_t length,
10661                                         const void *param, void *user_data)
10662 {
10663         bool bthost = PTR_TO_INT(user_data);
10664
10665         if (status != MGMT_STATUS_SUCCESS) {
10666                 tester_setup_failed();
10667                 return;
10668         }
10669
10670         tester_print("Device is Removed");
10671
10672         if (bthost)
10673                 setup_bthost();
10674 }
10675
10676 static void setup_add_adv_callback(uint8_t status, uint16_t length,
10677                                         const void *param, void *user_data)
10678 {
10679         struct mgmt_rp_add_advertising *rp =
10680                                 (struct mgmt_rp_add_advertising *) param;
10681
10682         if (status != MGMT_STATUS_SUCCESS) {
10683                 tester_setup_failed();
10684                 return;
10685         }
10686
10687         tester_print("Add Advertising setup complete (instance %d)",
10688                                                                 rp->instance);
10689 }
10690
10691 static void setup_add_adv_callback_adv(uint8_t status, uint16_t length,
10692                                         const void *param, void *user_data)
10693 {
10694         struct test_data *data = tester_get_data();
10695         struct mgmt_cp_add_advertising *cp;
10696         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
10697         struct mgmt_rp_add_advertising *rp =
10698                                 (struct mgmt_rp_add_advertising *) param;
10699
10700         if (status != MGMT_STATUS_SUCCESS) {
10701                 tester_setup_failed();
10702                 return;
10703         }
10704
10705         tester_print("Add Advertising setup complete (instance %d)",
10706                                                                 rp->instance);
10707
10708         /* Add another advertising */
10709         cp = (struct mgmt_cp_add_advertising *) adv_param;
10710         setup_add_adv_param(cp, 2);
10711
10712         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
10713                                         sizeof(adv_param), adv_param,
10714                                         setup_add_advertising_callback,
10715                                         NULL, NULL);
10716 }
10717
10718 static void setup_ll_privacy_with_irk1(const void *test_data)
10719 {
10720         struct test_data *data = tester_get_data();
10721         unsigned char param[] = { 0x01 };
10722
10723         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10724                                         sizeof(load_irks_le_public_param_1),
10725                                         load_irks_le_public_param_1,
10726                                         setup_load_irks_callback, NULL, NULL);
10727
10728         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10729                                         sizeof(param), param,
10730                                         setup_powered_callback, NULL, NULL);
10731
10732 }
10733
10734 static void setup_ll_privacy_dev1_and_irk2(const void *test_data)
10735 {
10736         struct test_data *data = tester_get_data();
10737         unsigned char param[] = { 0x01 };
10738
10739         /* Add IRKs of Device1 and Device2 */
10740         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10741                                         sizeof(load_irks_2_devices_param),
10742                                         load_irks_2_devices_param,
10743                                         setup_load_irks_callback, NULL, NULL);
10744
10745         /* Add Device 1 */
10746         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10747                                         sizeof(add_device_le_public_param_1),
10748                                         add_device_le_public_param_1,
10749                                         setup_add_device_callback, NULL, NULL);
10750
10751         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10752                                         sizeof(param), param,
10753                                         setup_powered_callback, NULL, NULL);
10754 }
10755
10756 static void setup_ll_privacy_3_devices(const void *test_data)
10757 {
10758         struct test_data *data = tester_get_data();
10759         unsigned char param[] = { 0x01 };
10760
10761         /* Add IRKs of 4 Devices */
10762         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10763                                         sizeof(load_irks_4_devices_param),
10764                                         load_irks_4_devices_param,
10765                                         setup_load_irks_callback, NULL, NULL);
10766
10767         /* Add Device 1 */
10768         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10769                                         sizeof(add_device_le_public_param_1),
10770                                         add_device_le_public_param_1,
10771                                         setup_add_device_callback, NULL, NULL);
10772
10773         /* Add Device 2 */
10774         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10775                                         sizeof(add_device_le_public_param_2),
10776                                         add_device_le_public_param_2,
10777                                         setup_add_device_callback, NULL, NULL);
10778
10779         /* Add Device 3 */
10780         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10781                                         sizeof(add_device_le_public_param_3),
10782                                         add_device_le_public_param_3,
10783                                         setup_add_device_callback, NULL, NULL);
10784
10785         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10786                                         sizeof(param), param,
10787                                         setup_powered_callback, NULL, NULL);
10788 }
10789
10790 static void setup_ll_privacy_2_devices_extra_rl(const void *test_data)
10791 {
10792         struct test_data *data = tester_get_data();
10793         unsigned char param[] = { 0x01 };
10794
10795         hciemu_set_central_le_rl_len(data->hciemu, 2);
10796
10797         /* Add IRKs of 4 Devices */
10798         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10799                                         sizeof(load_irks_4_devices_param),
10800                                         load_irks_4_devices_param,
10801                                         setup_load_irks_callback, NULL, NULL);
10802
10803         /* Add Device 1 */
10804         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10805                                         sizeof(add_device_le_public_param_1),
10806                                         add_device_le_public_param_1,
10807                                         setup_add_device_callback, NULL, NULL);
10808
10809         /* Add Device 2 */
10810         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10811                                         sizeof(add_device_le_public_param_2),
10812                                         add_device_le_public_param_2,
10813                                         setup_add_device_callback, NULL, NULL);
10814
10815         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10816                                         sizeof(param), param,
10817                                         setup_powered_callback, NULL, NULL);
10818 }
10819
10820 static void setup_ll_privacy_2_devices_extra_al(const void *test_data)
10821 {
10822         struct test_data *data = tester_get_data();
10823         unsigned char param[] = { 0x01 };
10824
10825         hciemu_set_central_le_al_len(data->hciemu, 2);
10826
10827         /* Add IRKs of 3 Devices */
10828         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10829                                         sizeof(load_irks_3_devices_param),
10830                                         load_irks_3_devices_param,
10831                                         setup_load_irks_callback, NULL, NULL);
10832
10833         /* Add Device 1 */
10834         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10835                                         sizeof(add_device_le_public_param_1),
10836                                         add_device_le_public_param_1,
10837                                         setup_add_device_callback, NULL, NULL);
10838
10839         /* Add Device 2 */
10840         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10841                                         sizeof(add_device_le_public_param_2),
10842                                         add_device_le_public_param_2,
10843                                         setup_add_device_callback, NULL, NULL);
10844
10845         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10846                                         sizeof(param), param,
10847                                         setup_powered_callback, NULL, NULL);
10848 }
10849
10850 /* Enable LL Privacy and Add 2 devices */
10851 static void setup_ll_privacy_device2_discovry(const void *test_data)
10852 {
10853         struct test_data *data = tester_get_data();
10854         unsigned char param[] = { 0x01 };
10855         uint8_t disc_param[] = { 0x06 };
10856
10857         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10858                                         sizeof(param), param,
10859                                         setup_powered_callback, NULL, NULL);
10860         /* Load IRKs */
10861         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10862                                         sizeof(load_irks_2_devices_param),
10863                                         load_irks_2_devices_param,
10864                                         setup_load_irks_callback, NULL, NULL);
10865
10866         /* Load Device1 */
10867         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10868                                         sizeof(add_device_le_public_param_1),
10869                                         add_device_le_public_param_1,
10870                                         setup_add_device_callback, NULL, NULL);
10871
10872         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10873                                         sizeof(add_device_le_public_param_2),
10874                                         add_device_le_public_param_2,
10875                                         setup_add_device_callback, NULL, NULL);
10876
10877         mgmt_send(data->mgmt, MGMT_OP_START_DISCOVERY, data->mgmt_index,
10878                                         sizeof(disc_param), disc_param,
10879                                         setup_discovery_callback, NULL, NULL);
10880
10881         mgmt_send(data->mgmt, MGMT_OP_STOP_DISCOVERY, data->mgmt_index,
10882                                         sizeof(disc_param), disc_param,
10883                                         setup_discovery_callback, NULL, NULL);
10884
10885         mgmt_send(data->mgmt, MGMT_OP_REMOVE_DEVICE, data->mgmt_index,
10886                                         sizeof(add_device_rsp_le_public),
10887                                         add_device_rsp_le_public,
10888                                         setup_remove_device_callback,
10889                                         NULL, NULL);
10890 }
10891
10892 /* Enable LL Privacy and Add Advertising */
10893 static void setup_ll_privacy_adv(const void *test_data)
10894 {
10895         struct test_data *data = tester_get_data();
10896         struct mgmt_cp_add_advertising *cp;
10897         unsigned char param[] = { 0x01 };
10898         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
10899
10900         cp = (struct mgmt_cp_add_advertising *) adv_param;
10901         setup_add_adv_param(cp, 1);
10902
10903         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
10904                                         sizeof(adv_param), adv_param,
10905                                         setup_add_adv_callback, NULL, NULL);
10906
10907         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10908                                         sizeof(param), param,
10909                                         setup_powered_callback, NULL, NULL);
10910 }
10911
10912 /* Enable LL Privacy and Add Advertising */
10913 static void setup_ll_privacy_2_advs(const void *test_data)
10914 {
10915         struct test_data *data = tester_get_data();
10916         struct mgmt_cp_add_advertising *cp;
10917         unsigned char param[] = { 0x01 };
10918         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
10919
10920         cp = (struct mgmt_cp_add_advertising *) adv_param;
10921         setup_add_adv_param(cp, 1);
10922
10923         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10924                                         sizeof(load_irks_le_public_param_1),
10925                                         load_irks_le_public_param_1,
10926                                         setup_load_irks_callback, NULL, NULL);
10927
10928         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10929                                         sizeof(param), param,
10930                                         NULL, NULL, NULL);
10931
10932         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
10933                                         sizeof(adv_param), adv_param,
10934                                         setup_add_adv_callback_adv, NULL, NULL);
10935 }
10936
10937 static void setup_ll_privacy_dev_2_advs(const void *test_data)
10938 {
10939         struct test_data *data = tester_get_data();
10940         struct mgmt_cp_add_advertising *cp;
10941         unsigned char param[] = { 0x01 };
10942         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
10943
10944         cp = (struct mgmt_cp_add_advertising *) adv_param;
10945         setup_add_adv_param(cp, 1);
10946
10947         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10948                                         sizeof(load_irks_le_public_param_1),
10949                                         load_irks_le_public_param_1,
10950                                         setup_load_irks_callback, NULL, NULL);
10951
10952         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
10953                                         sizeof(param), param,
10954                                         NULL, NULL, NULL);
10955
10956         /* Add Device 2 */
10957         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10958                                         sizeof(add_device_le_public_param_2),
10959                                         add_device_le_public_param_2,
10960                                         setup_add_device_callback, NULL, NULL);
10961
10962         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
10963                                         sizeof(adv_param), adv_param,
10964                                         setup_add_adv_callback_adv, NULL, NULL);
10965 }
10966
10967 static void setup_ll_privacy_adv_3_devices(const void *test_data)
10968 {
10969         struct test_data *data = tester_get_data();
10970         struct mgmt_cp_add_advertising *cp;
10971         unsigned char param[] = { 0x01 };
10972         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
10973
10974         cp = (struct mgmt_cp_add_advertising *) adv_param;
10975         setup_add_adv_param(cp, 1);
10976
10977         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
10978                                         sizeof(adv_param), adv_param,
10979                                         setup_add_adv_callback, NULL, NULL);
10980
10981         /* Add IRKs of 4 Devices */
10982         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
10983                                         sizeof(load_irks_4_devices_param),
10984                                         load_irks_4_devices_param,
10985                                         setup_load_irks_callback, NULL, NULL);
10986
10987         /* Add Device 1 */
10988         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10989                                         sizeof(add_device_le_public_param_1),
10990                                         add_device_le_public_param_1,
10991                                         setup_add_device_callback, NULL, NULL);
10992
10993         /* Add Device 2 */
10994         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
10995                                         sizeof(add_device_le_public_param_2),
10996                                         add_device_le_public_param_2,
10997                                         setup_add_device_callback, NULL, NULL);
10998
10999         /* Add Device 3 */
11000         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11001                                         sizeof(add_device_le_public_param_3),
11002                                         add_device_le_public_param_3,
11003                                         setup_add_device_callback, NULL, NULL);
11004
11005         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
11006                                         sizeof(param), param,
11007                                         setup_powered_callback, NULL, NULL);
11008 }
11009
11010 static void setup_ll_privacy_adv_1_device_2_advs(const void *test_data)
11011 {
11012         struct test_data *data = tester_get_data();
11013         struct mgmt_cp_add_advertising *cp;
11014         unsigned char param[] = { 0x01 };
11015         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
11016
11017         cp = (struct mgmt_cp_add_advertising *) adv_param;
11018         setup_add_adv_param(cp, 1);
11019
11020         /* Add IRKs of 4 Devices */
11021         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
11022                                         sizeof(load_irks_4_devices_param),
11023                                         load_irks_4_devices_param,
11024                                         setup_load_irks_callback, NULL, NULL);
11025
11026         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
11027                                         sizeof(param), param,
11028                                         NULL, NULL, NULL);
11029
11030         /* Add Device 1 */
11031         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11032                                         sizeof(add_device_le_public_param_1),
11033                                         add_device_le_public_param_1,
11034                                         setup_add_device_callback, NULL, NULL);
11035
11036         /* Add Device 2 */
11037         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11038                                         sizeof(add_device_le_public_param_2),
11039                                         add_device_le_public_param_2,
11040                                         setup_add_device_callback, NULL, NULL);
11041
11042         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
11043                                         sizeof(adv_param), adv_param,
11044                                         setup_add_adv_callback_adv, NULL, NULL);
11045 }
11046
11047 static void setup_add_2_advertisings(const void *test_data)
11048 {
11049         struct test_data *data = tester_get_data();
11050         struct mgmt_cp_add_advertising *cp;
11051         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
11052         unsigned char param[] = { 0x01 };
11053
11054         tester_print("Adding advertising instance while powered");
11055
11056         cp = (struct mgmt_cp_add_advertising *) adv_param;
11057         setup_add_adv_param(cp, 1);
11058
11059         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
11060                                                 sizeof(param), &param,
11061                                                 NULL, NULL, NULL);
11062
11063         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
11064                                         sizeof(param), param,
11065                                         NULL, NULL, NULL);
11066
11067         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
11068                                                 sizeof(adv_param), adv_param,
11069                                                 setup_add_adv_callback_adv,
11070                                                 NULL, NULL);
11071 }
11072
11073 static void setup_add_2_advertisings_no_power(const void *test_data)
11074 {
11075         struct test_data *data = tester_get_data();
11076         struct mgmt_cp_add_advertising *cp;
11077         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
11078         unsigned char param[] = { 0x01 };
11079
11080         tester_print("Adding advertising instance while not powered");
11081
11082         cp = (struct mgmt_cp_add_advertising *) adv_param;
11083         setup_add_adv_param(cp, 1);
11084
11085         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
11086                                                 sizeof(param), &param,
11087                                                 NULL, NULL, NULL);
11088
11089         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
11090                                                 sizeof(adv_param), adv_param,
11091                                                 setup_add_adv_callback_adv,
11092                                                 NULL, NULL);
11093 }
11094
11095 static void setup_ll_privacy_enable_powered(const void *test_data)
11096 {
11097         struct test_data *data = tester_get_data();
11098         unsigned char param[] = { 0x01 };
11099         struct bthost *bthost;
11100
11101         bthost = hciemu_client_get_host(data->hciemu);
11102         bthost_set_scan_params(bthost, 0x01, 0x00, 0x00);
11103         bthost_set_scan_enable(bthost, 0x01);
11104
11105         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
11106                                         sizeof(param), param,
11107                                         setup_powered_callback, NULL, NULL);
11108 }
11109
11110 static void setup_ll_privacy_add_adv(const void *test_data)
11111 {
11112         struct test_data *data = tester_get_data();
11113         const struct generic_data *test = data->test_data;
11114         unsigned char param[] = { 0x01 };
11115         unsigned char set_adv_param[] = { 0x02 };
11116         struct bthost *bthost;
11117
11118         /* Setup bthost to enable the scan */
11119         bthost = hciemu_client_get_host(data->hciemu);
11120         bthost_set_scan_params(bthost, 0x01, 0x00, 0x00);
11121         bthost_set_scan_enable(bthost, 0x01);
11122
11123         mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
11124                                                 sizeof(param), &param,
11125                                                 NULL, NULL, NULL);
11126
11127         mgmt_send(data->mgmt, MGMT_OP_SET_BONDABLE, data->mgmt_index,
11128                                                 sizeof(param), &param,
11129                                                 NULL, NULL, NULL);
11130
11131         mgmt_send(data->mgmt, MGMT_OP_SET_IO_CAPABILITY, data->mgmt_index,
11132                                         sizeof(test->io_cap), &test->io_cap,
11133                                         NULL, NULL, NULL);
11134
11135         mgmt_send(data->mgmt, MGMT_OP_SET_ADVERTISING, data->mgmt_index,
11136                                                 sizeof(set_adv_param),
11137                                                 &set_adv_param,
11138                                                 NULL, NULL, NULL);
11139
11140         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
11141                                         sizeof(param), param,
11142                                         setup_powered_callback, NULL, NULL);
11143 }
11144
11145 static void setup_ll_privacy_add_device(const void *test_data)
11146 {
11147         struct test_data *data = tester_get_data();
11148         unsigned char param[] = { 0x01 };
11149
11150         mgmt_send(data->mgmt, MGMT_OP_LOAD_IRKS, data->mgmt_index,
11151                                         sizeof(load_irks_le_public_param_1),
11152                                         load_irks_le_public_param_1,
11153                                         setup_load_irks_callback, NULL, NULL);
11154
11155         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
11156                                         sizeof(param), param,
11157                                         setup_powered_callback, NULL, NULL);
11158
11159         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11160                                         sizeof(add_device_le_public_param_1),
11161                                         add_device_le_public_param_1,
11162                                         setup_add_device_callback, NULL, NULL);
11163
11164 }
11165
11166 static bool power_off(uint16_t index)
11167 {
11168         int sk, err;
11169
11170         sk = hci_open_dev(index);
11171         if (sk < 0)
11172                 return false;
11173
11174         err = ioctl(sk, HCIDEVDOWN, index);
11175
11176         hci_close_dev(sk);
11177
11178         if (err < 0)
11179                 return false;
11180
11181         return true;
11182 }
11183
11184 /* Read HCI commands in the expect_hci_list and add it to the queue
11185  */
11186 static void add_expect_hci_list(struct test_data *data)
11187 {
11188         const struct generic_data *test = data->test_data;
11189         const struct hci_cmd_data *hci_cmd_data;
11190
11191         /* Initialize the queue */
11192         data->expect_hci_q = queue_new();
11193
11194         hci_cmd_data = test->expect_hci_list;
11195         for (; hci_cmd_data->opcode; hci_cmd_data++) {
11196                 struct hci_entry *entry;
11197
11198                 entry = new0(struct hci_entry, 1);
11199                 entry->cmd_data = hci_cmd_data;
11200                 queue_push_tail(data->expect_hci_q, entry);
11201
11202                 test_add_condition(data);
11203         }
11204 }
11205
11206 static void test_command_generic(const void *test_data)
11207 {
11208         struct test_data *data = tester_get_data();
11209         const struct generic_data *test = data->test_data;
11210         const void *send_param = test->send_param;
11211         uint16_t send_len = test->send_len;
11212         unsigned int id;
11213         uint16_t index;
11214
11215         index = test->send_index_none ? MGMT_INDEX_NONE : data->mgmt_index;
11216
11217         if (test->expect_settings_set || test->expect_settings_unset) {
11218                 tester_print("Registering new settings notification");
11219
11220                 id = mgmt_register(data->mgmt, MGMT_EV_NEW_SETTINGS, index,
11221                                 command_generic_new_settings, NULL, NULL);
11222                 data->mgmt_settings_id = id;
11223
11224                 id = mgmt_register(data->mgmt_alt, MGMT_EV_NEW_SETTINGS, index,
11225                                 command_generic_new_settings_alt, NULL, NULL);
11226                 data->mgmt_alt_settings_id = id;
11227                 test_add_condition(data);
11228         }
11229
11230         if (test->expect_alt_ev) {
11231                 tester_print("Registering %s notification",
11232                                         mgmt_evstr(test->expect_alt_ev));
11233                 id = mgmt_register(data->mgmt_alt, test->expect_alt_ev, index,
11234                                         command_generic_event_alt, NULL, NULL);
11235                 data->mgmt_alt_ev_id = id;
11236                 test_add_condition(data);
11237         }
11238
11239         if (test->expect_hci_command) {
11240                 tester_print("Registering HCI command callback");
11241                 hciemu_add_central_post_command_hook(data->hciemu,
11242                                                 command_hci_callback, data);
11243                 test_add_condition(data);
11244         } else if (test->expect_hci_list) {
11245                 /* Use this when it needs to check more than 1 hci command.
11246                  * However, it cannot be used with expect_hci_command.
11247                  */
11248                 tester_print("Registering HCI command list callback");
11249                 hciemu_add_central_post_command_hook(data->hciemu,
11250                                         command_hci_list_callback, data);
11251                 add_expect_hci_list(data);
11252         }
11253
11254         if (test->send_opcode == 0x0000) {
11255                 tester_print("Executing no-op test");
11256                 return;
11257         }
11258
11259         tester_print("Sending %s (0x%04x)", mgmt_opstr(test->send_opcode),
11260                                                         test->send_opcode);
11261
11262         if (test->send_func)
11263                 send_param = test->send_func(&send_len);
11264
11265         if (test->force_power_off) {
11266                 mgmt_send_nowait(data->mgmt, test->send_opcode, index,
11267                                         send_len, send_param,
11268                                         command_generic_callback, NULL, NULL);
11269                 power_off(data->mgmt_index);
11270         } else {
11271                 mgmt_send(data->mgmt, test->send_opcode, index, send_len,
11272                                         send_param, command_generic_callback,
11273                                         NULL, NULL);
11274         }
11275
11276         test_add_condition(data);
11277 }
11278
11279 static void check_scan(void *user_data)
11280 {
11281         struct test_data *data = tester_get_data();
11282
11283         if (hciemu_get_central_le_scan_enable(data->hciemu)) {
11284                 tester_warn("LE scan still enabled");
11285                 tester_test_failed();
11286                 return;
11287         }
11288
11289         if (hciemu_get_central_scan_enable(data->hciemu)) {
11290                 tester_warn("BR/EDR scan still enabled");
11291                 tester_test_failed();
11292                 return;
11293         }
11294
11295         test_condition_complete(data);
11296 }
11297
11298 static void test_remove_device(const void *test_data)
11299 {
11300         struct test_data *data = tester_get_data();
11301
11302         test_command_generic(test_data);
11303         tester_wait(1, check_scan, NULL);
11304         test_add_condition(data);
11305 }
11306
11307 static void trigger_device_found(void *user_data)
11308 {
11309         struct test_data *data = tester_get_data();
11310         const struct generic_data *test = data->test_data;
11311         struct bthost *bthost;
11312
11313         bthost = hciemu_client_get_host(data->hciemu);
11314
11315         if ((data->hciemu_type == HCIEMU_TYPE_LE) ||
11316                                 (data->hciemu_type == HCIEMU_TYPE_BREDRLE)) {
11317                 if (test->set_adv)
11318                         bthost_set_adv_data(bthost, test->adv_data,
11319                                                         test->adv_data_len);
11320
11321                 bthost_set_adv_enable(bthost, 0x01);
11322         } else if (data->hciemu_type >= HCIEMU_TYPE_BREDRLE50) {
11323                 bthost_set_ext_adv_params(bthost);
11324                 if (test->set_adv)
11325                         bthost_set_ext_adv_data(bthost, test->adv_data,
11326                                                         test->adv_data_len);
11327
11328                 bthost_set_ext_adv_enable(bthost, 0x01);
11329         }
11330
11331         if (data->hciemu_type != HCIEMU_TYPE_LE)
11332                 bthost_write_scan_enable(bthost, 0x03);
11333
11334         test_condition_complete(data);
11335 }
11336
11337 static void test_device_found(const void *test_data)
11338 {
11339         struct test_data *data = tester_get_data();
11340
11341         test_command_generic(test_data);
11342
11343         /* Make sure discovery is enabled before enabling advertising. */
11344         tester_wait(1, trigger_device_found, NULL);
11345         test_add_condition(data);
11346 }
11347
11348 static void pairing_new_conn(uint16_t handle, void *user_data)
11349 {
11350         struct test_data *data = tester_get_data();
11351         struct bthost *bthost;
11352
11353         tester_print("New connection with handle 0x%04x", handle);
11354
11355         bthost = hciemu_client_get_host(data->hciemu);
11356
11357         bthost_request_auth(bthost, handle);
11358 }
11359
11360 static void test_pairing_acceptor(const void *test_data)
11361 {
11362         struct test_data *data = tester_get_data();
11363         const struct generic_data *test = data->test_data;
11364         const uint8_t *central_bdaddr;
11365         struct bthost *bthost;
11366         uint8_t addr_type;
11367
11368         if (test->expect_alt_ev) {
11369                 unsigned int id;
11370
11371                 tester_print("Registering %s notification",
11372                                         mgmt_evstr(test->expect_alt_ev));
11373                 id = mgmt_register(data->mgmt_alt, test->expect_alt_ev,
11374                                         data->mgmt_index,
11375                                         command_generic_event_alt, NULL, NULL);
11376                 data->mgmt_alt_ev_id = id;
11377                 test_add_condition(data);
11378         }
11379
11380         central_bdaddr = hciemu_get_central_bdaddr(data->hciemu);
11381         if (!central_bdaddr) {
11382                 tester_warn("No central bdaddr");
11383                 tester_test_failed();
11384                 return;
11385         }
11386
11387         bthost = hciemu_client_get_host(data->hciemu);
11388         bthost_set_connect_cb(bthost, pairing_new_conn, data);
11389
11390         if (data->hciemu_type == HCIEMU_TYPE_BREDRLE)
11391                 addr_type = BDADDR_BREDR;
11392         else
11393                 addr_type = BDADDR_LE_PUBLIC;
11394
11395         bthost_hci_connect(bthost, central_bdaddr, addr_type);
11396 }
11397
11398
11399 static void check_le_ext_adv_discovery(void *user_data)
11400 {
11401         struct test_data *data = tester_get_data();
11402         const uint8_t *adv_addr;
11403         struct bthost *bthost;
11404
11405         adv_addr = hciemu_get_central_adv_addr(data->hciemu, 0x00);
11406         if (!adv_addr) {
11407                 tester_warn("No EXT ADV Address");
11408                 tester_test_failed();
11409                 return;
11410         }
11411
11412         bthost = hciemu_client_get_host(data->hciemu);
11413         if (bthost_search_ext_adv_addr(bthost, adv_addr))
11414                 tester_test_passed();
11415         else
11416                 tester_test_failed();
11417
11418         test_condition_complete(data);
11419 }
11420
11421 static void test_ll_privacy_bthost_scan_report(const void *test_data)
11422 {
11423         struct test_data *data = tester_get_data();
11424
11425         test_command_generic(test_data);
11426         tester_wait(1, check_le_ext_adv_discovery, NULL);
11427         test_add_condition(data);
11428 }
11429
11430 static void test_pairing_acceptor_ll_privacy_le_random(const void *test_data)
11431 {
11432         struct test_data *data = tester_get_data();
11433         const struct generic_data *test = data->test_data;
11434         const uint8_t *adv_addr;
11435         struct bthost *bthost;
11436
11437         if (test->expect_alt_ev) {
11438                 unsigned int id;
11439
11440                 tester_print("Registering %s notification",
11441                                         mgmt_evstr(test->expect_alt_ev));
11442                 id = mgmt_register(data->mgmt_alt, test->expect_alt_ev,
11443                                         data->mgmt_index,
11444                                         command_generic_event_alt, NULL, NULL);
11445                 data->mgmt_alt_ev_id = id;
11446                 test_add_condition(data);
11447         }
11448
11449         adv_addr = hciemu_get_central_adv_addr(data->hciemu, 0x00);
11450         if (!adv_addr) {
11451                 tester_warn("No EXT ADV Address");
11452                 tester_test_failed();
11453                 return;
11454         }
11455
11456         tester_print("Ext Adv Address: %02x:%02x:%02x:%02x:%02x:%02x",
11457                         adv_addr[0], adv_addr[1], adv_addr[2],
11458                         adv_addr[3], adv_addr[4], adv_addr[5]);
11459
11460         bthost = hciemu_client_get_host(data->hciemu);
11461         bthost_set_connect_cb(bthost, pairing_new_conn, data);
11462
11463         bthost_hci_ext_connect(bthost, adv_addr, BDADDR_LE_RANDOM);
11464 }
11465
11466 static void new_link_key_evt_pair_2_callback(uint16_t index, uint16_t length,
11467                                                         const void *param,
11468                                                         void *user_data)
11469 {
11470         struct test_data *data = tester_get_data();
11471
11472         tester_print("New %s event received", mgmt_evstr(MGMT_EV_NEW_LINK_KEY));
11473
11474         mgmt_unregister(data->mgmt, data->mgmt_discov_ev_id);
11475
11476         /* TODO: validate the event */
11477         test_condition_complete(data);
11478 }
11479
11480 static void test_ll_privacy_pair_2(const void *test_data)
11481 {
11482         struct test_data *data = tester_get_data();
11483         unsigned int id;
11484
11485         test_command_generic(test_data);
11486
11487         tester_print("Registering New Link Key notification");
11488         id = mgmt_register(data->mgmt, MGMT_EV_NEW_LINK_KEY,
11489                            data->mgmt_index, new_link_key_evt_pair_2_callback,
11490                            NULL, NULL);
11491         /* Reuse the variable */
11492         data->mgmt_discov_ev_id = id;
11493         test_add_condition(data);
11494 }
11495
11496 static void unpair_device_command_callback(uint8_t status, uint16_t length,
11497                                         const void *param, void *user_data)
11498 {
11499         struct test_data *data = tester_get_data();
11500
11501         tester_print("%s (0x%04x): %s (0x%02x)",
11502                      mgmt_opstr(MGMT_OP_UNPAIR_DEVICE),
11503                      MGMT_OP_UNPAIR_DEVICE, mgmt_errstr(status), status);
11504
11505         if (status != MGMT_STATUS_SUCCESS) {
11506                 tester_warn("Unexpected status got %d expected %d",
11507                                                 status, MGMT_STATUS_SUCCESS);
11508                 tester_test_failed();
11509                 return;
11510         }
11511         test_condition_complete(data);
11512 }
11513
11514 static void unpair_device(void *user_data)
11515 {
11516         struct test_data *data = tester_get_data();
11517
11518         tester_print("Sending %s (0x%04x)", mgmt_opstr(MGMT_OP_UNPAIR_DEVICE),
11519                                                         MGMT_OP_UNPAIR_DEVICE);
11520
11521         /* Send Unpair command */
11522         mgmt_send(data->mgmt, MGMT_OP_UNPAIR_DEVICE, data->mgmt_index,
11523                   sizeof(unpair_client_1), unpair_client_1,
11524                   unpair_device_command_callback, NULL, NULL);
11525         test_add_condition(data);
11526 }
11527
11528 static void disconnect_device_command_callback(uint8_t status, uint16_t length,
11529                                         const void *param, void *user_data)
11530 {
11531         struct test_data *data = tester_get_data();
11532
11533         tester_print("%s (0x%04x): %s (0x%02x)",
11534                      mgmt_opstr(MGMT_OP_DISCONNECT),
11535                      MGMT_OP_DISCONNECT, mgmt_errstr(status), status);
11536
11537         if (status != MGMT_STATUS_SUCCESS) {
11538                 tester_warn("Unexpected status got %d expected %d",
11539                                                 status, MGMT_STATUS_SUCCESS);
11540                 tester_test_failed();
11541                 return;
11542         }
11543         test_condition_complete(data);
11544
11545         unpair_device(NULL);
11546 }
11547
11548 static void unpair_disconnect_device(void *user_data)
11549 {
11550         struct test_data *data = tester_get_data();
11551
11552         tester_print("Sending %s (0x%04x)", mgmt_opstr(MGMT_OP_DISCONNECT),
11553                                                         MGMT_OP_DISCONNECT);
11554
11555         /* Send Unpair command */
11556         mgmt_send(data->mgmt, MGMT_OP_DISCONNECT, data->mgmt_index,
11557                   sizeof(remove_paired_device_1), remove_paired_device_1,
11558                   disconnect_device_command_callback, NULL, NULL);
11559
11560         test_add_condition(data);
11561 }
11562
11563 static void new_link_key_evt_unpair_callback(uint16_t index, uint16_t length,
11564                                                         const void *param,
11565                                                         void *user_data)
11566 {
11567         struct test_data *data = tester_get_data();
11568
11569         tester_print("New %s event received", mgmt_evstr(MGMT_EV_NEW_LINK_KEY));
11570
11571         mgmt_unregister(data->mgmt, data->mgmt_discov_ev_id);
11572
11573         /* TODO: validate the event */
11574         test_condition_complete(data);
11575
11576         /* Wait 1 sec for pairing command complete event */
11577         tester_wait(1, unpair_disconnect_device, NULL);
11578 }
11579
11580 static void test_ll_privacy_unpair(const void *test_data)
11581 {
11582         struct test_data *data = tester_get_data();
11583         unsigned int id;
11584
11585         test_command_generic(test_data);
11586
11587         tester_print("Registering New Link Key notification");
11588         id = mgmt_register(data->mgmt, MGMT_EV_NEW_LINK_KEY,
11589                            data->mgmt_index, new_link_key_evt_unpair_callback,
11590                            NULL, NULL);
11591         /* Reuse the variable */
11592         data->mgmt_discov_ev_id = id;
11593         test_add_condition(data);
11594 }
11595
11596 static void remove_device_command_callback(uint8_t status, uint16_t length,
11597                                         const void *param, void *user_data)
11598 {
11599         struct test_data *data = tester_get_data();
11600
11601         tester_print("%s (0x%04x): %s (0x%02x)",
11602                      mgmt_opstr(MGMT_OP_REMOVE_DEVICE),
11603                      MGMT_OP_REMOVE_DEVICE, mgmt_errstr(status), status);
11604
11605         if (status != MGMT_STATUS_SUCCESS) {
11606                 tester_warn("Unexpected status got %d expected %d",
11607                                                 status, MGMT_STATUS_SUCCESS);
11608                 tester_test_failed();
11609                 return;
11610         }
11611         test_condition_complete(data);
11612
11613         unpair_device(NULL);
11614 }
11615
11616 static void remove_device(void *user_data)
11617 {
11618         struct test_data *data = tester_get_data();
11619
11620         tester_print("Sending %s (0x%04x)", mgmt_opstr(MGMT_OP_REMOVE_DEVICE),
11621                                                         MGMT_OP_REMOVE_DEVICE);
11622
11623         /* Send Unpair command */
11624         mgmt_send(data->mgmt, MGMT_OP_REMOVE_DEVICE, data->mgmt_index,
11625                   sizeof(remove_paired_device_1), remove_paired_device_1,
11626                   remove_device_command_callback, NULL, NULL);
11627         test_add_condition(data);
11628 }
11629
11630 static void add_device_2_command_callback(uint8_t status, uint16_t length,
11631                                         const void *param, void *user_data)
11632 {
11633         struct test_data *data = tester_get_data();
11634
11635         tester_print("%s (0x%04x): %s (0x%02x)",
11636                      mgmt_opstr(MGMT_OP_ADD_DEVICE),
11637                      MGMT_OP_ADD_DEVICE, mgmt_errstr(status), status);
11638
11639         if (status != MGMT_STATUS_SUCCESS) {
11640                 tester_warn("Unexpected status got %d expected %d",
11641                                                 status, MGMT_STATUS_SUCCESS);
11642                 tester_test_failed();
11643                 return;
11644         }
11645
11646         test_condition_complete(data);
11647
11648         remove_device(NULL);
11649 }
11650
11651 static void add_device_2(void *user_data)
11652 {
11653         struct test_data *data = tester_get_data();
11654
11655         tester_print("Sending %s (0x%04x)", mgmt_opstr(MGMT_OP_ADD_DEVICE),
11656                                                         MGMT_OP_ADD_DEVICE);
11657
11658         /* Send Add Device command */
11659         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11660                   sizeof(add_device_le_public_param_1),
11661                   add_device_le_public_param_1,
11662                   add_device_2_command_callback, NULL, NULL);
11663
11664         test_add_condition(data);
11665 }
11666
11667 static void add_device_command_callback(uint8_t status, uint16_t length,
11668                                         const void *param, void *user_data)
11669 {
11670         struct test_data *data = tester_get_data();
11671
11672         tester_print("%s (0x%04x): %s (0x%02x)",
11673                      mgmt_opstr(MGMT_OP_ADD_DEVICE),
11674                      MGMT_OP_ADD_DEVICE, mgmt_errstr(status), status);
11675
11676         if (status != MGMT_STATUS_SUCCESS) {
11677                 tester_warn("Unexpected status got %d expected %d",
11678                                                 status, MGMT_STATUS_SUCCESS);
11679                 tester_test_failed();
11680                 return;
11681         }
11682         test_condition_complete(data);
11683
11684         add_device_2(NULL);
11685 }
11686
11687 static void add_device(void *user_data)
11688 {
11689         struct test_data *data = tester_get_data();
11690
11691         tester_print("Sending %s (0x%04x)", mgmt_opstr(MGMT_OP_ADD_DEVICE),
11692                                                         MGMT_OP_ADD_DEVICE);
11693
11694         /* Send Unpair command */
11695         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11696                   sizeof(add_paired_client_1), add_paired_client_1,
11697                   add_device_command_callback, NULL, NULL);
11698         test_add_condition(data);
11699 }
11700
11701 static void unpair_2_disconnect_command_callback(uint8_t status,
11702                                                  uint16_t length,
11703                                                  const void *param,
11704                                                  void *user_data)
11705 {
11706         struct test_data *data = tester_get_data();
11707
11708         tester_print("%s (0x%04x): %s (0x%02x)",
11709                      mgmt_opstr(MGMT_OP_DISCONNECT),
11710                      MGMT_OP_DISCONNECT, mgmt_errstr(status), status);
11711
11712         if (status != MGMT_STATUS_SUCCESS) {
11713                 tester_warn("Unexpected status got %d expected %d",
11714                                                 status, MGMT_STATUS_SUCCESS);
11715                 tester_test_failed();
11716                 return;
11717         }
11718         test_condition_complete(data);
11719
11720         add_device(NULL);
11721 }
11722
11723 static void unpair_2_disconnect_device(void *user_data)
11724 {
11725         struct test_data *data = tester_get_data();
11726
11727         tester_print("Sending %s (0x%04x)", mgmt_opstr(MGMT_OP_DISCONNECT),
11728                                                         MGMT_OP_DISCONNECT);
11729
11730         /* Send Unpair command */
11731         mgmt_send(data->mgmt, MGMT_OP_DISCONNECT, data->mgmt_index,
11732                   sizeof(remove_paired_device_1), remove_paired_device_1,
11733                   unpair_2_disconnect_command_callback, NULL, NULL);
11734
11735         test_add_condition(data);
11736 }
11737
11738 static void new_link_key_evt_add_dev_callback(uint16_t index, uint16_t length,
11739                                                         const void *param,
11740                                                         void *user_data)
11741 {
11742         struct test_data *data = tester_get_data();
11743
11744         tester_print("New %s event received", mgmt_evstr(MGMT_EV_NEW_LINK_KEY));
11745
11746         mgmt_unregister(data->mgmt, data->mgmt_discov_ev_id);
11747
11748         /* TODO: validate the event */
11749         test_condition_complete(data);
11750
11751         /* Wait 1 sec for pairing command complete event */
11752         tester_wait(1, unpair_2_disconnect_device, NULL);
11753 }
11754
11755 static void test_ll_privacy_unpair_2(const void *test_data)
11756 {
11757         struct test_data *data = tester_get_data();
11758         unsigned int id;
11759
11760         test_command_generic(test_data);
11761
11762         tester_print("Registering New Link Key notification");
11763         id = mgmt_register(data->mgmt, MGMT_EV_NEW_LINK_KEY,
11764                            data->mgmt_index, new_link_key_evt_add_dev_callback,
11765                            NULL, NULL);
11766         /* Reuse the variable */
11767         data->mgmt_discov_ev_id = id;
11768         test_add_condition(data);
11769 }
11770
11771 static void connected_event(uint16_t index, uint16_t length, const void *param,
11772                                                         void *user_data)
11773 {
11774         struct test_data *data = tester_get_data();
11775         const struct generic_data *test = data->test_data;
11776         const void *send_param = test->send_param;
11777         uint16_t send_len = test->send_len;
11778
11779         tester_print("Sending %s 0x%04x", mgmt_opstr(test->send_opcode),
11780                                                         test->send_opcode);
11781
11782         if (test->send_func)
11783                 send_param = test->send_func(&send_len);
11784
11785         if (test->force_power_off) {
11786                 mgmt_send_nowait(data->mgmt, test->send_opcode, index,
11787                                         send_len, send_param,
11788                                         command_generic_callback, NULL, NULL);
11789                 power_off(data->mgmt_index);
11790         } else {
11791                 mgmt_send(data->mgmt, test->send_opcode, index, send_len,
11792                                         send_param, command_generic_callback,
11793                                         NULL, NULL);
11794         }
11795
11796         test_add_condition(data);
11797
11798         /* Complete MGMT_EV_DEVICE_CONNECTED *after* adding new one */
11799         test_condition_complete(data);
11800 }
11801
11802 static void test_command_generic_connect(const void *test_data)
11803 {
11804         struct test_data *data = tester_get_data();
11805         unsigned int id;
11806         const uint8_t *central_bdaddr;
11807         uint8_t addr_type;
11808         struct bthost *bthost;
11809
11810         tester_print("Registering %s notification",
11811                                         mgmt_evstr(MGMT_EV_DEVICE_CONNECTED));
11812         id = mgmt_register(data->mgmt_alt, MGMT_EV_DEVICE_CONNECTED,
11813                                 data->mgmt_index, connected_event,
11814                                 NULL, NULL);
11815         data->mgmt_alt_ev_id = id;
11816         test_add_condition(data);
11817
11818         central_bdaddr = hciemu_get_central_bdaddr(data->hciemu);
11819         if (!central_bdaddr) {
11820                 tester_warn("No central bdaddr");
11821                 tester_test_failed();
11822                 return;
11823         }
11824
11825         addr_type = data->hciemu_type == HCIEMU_TYPE_BREDRLE ? BDADDR_BREDR :
11826                                                         BDADDR_LE_PUBLIC;
11827         tester_print("ADDR TYPE: %d", addr_type);
11828         bthost = hciemu_client_get_host(data->hciemu);
11829         bthost_hci_connect(bthost, central_bdaddr, addr_type);
11830 }
11831
11832 static bool test_adv_enable_hook(const void *data, uint16_t len,
11833                                                                 void *user_data)
11834 {
11835         struct test_data *test_data = user_data;
11836         const uint8_t *status = data;
11837
11838         if (*status == 0) {
11839                 tester_print("Advertising enabled");
11840                 test_condition_complete(test_data);
11841         } else {
11842                 tester_print("Advertising enabled error 0x%02x", *status);
11843         }
11844
11845         return true;
11846 }
11847
11848 static void disconnected_event(uint16_t index, uint16_t length,
11849                                         const void *param, void *user_data)
11850 {
11851         tester_test_failed();
11852 }
11853
11854 static void le_connected_event(uint16_t index, uint16_t length,
11855                                         const void *param, void *user_data)
11856 {
11857         struct test_data *data = tester_get_data();
11858
11859         tester_print("Device connected");
11860
11861         if (data->hciemu_type < HCIEMU_TYPE_BREDRLE50) {
11862                 test_add_condition(data);
11863                 hciemu_add_hook(data->hciemu, HCIEMU_HOOK_POST_CMD,
11864                                         BT_HCI_CMD_LE_SET_ADV_ENABLE,
11865                                         test_adv_enable_hook, data);
11866         }
11867
11868         /* Make sure we get not disconnected during the testaces */
11869         mgmt_register(data->mgmt_alt, MGMT_EV_DEVICE_DISCONNECTED,
11870                                 data->mgmt_index, disconnected_event,
11871                                 NULL, NULL);
11872
11873         test_condition_complete(data);
11874 }
11875
11876 static void add_device_callback(uint8_t status, uint16_t len, const void *param,
11877                                                         void *user_data)
11878 {
11879         struct test_data *data = user_data;
11880         const struct generic_data *test = data->test_data;
11881         struct bthost *bthost;
11882         const uint8_t *central_bdaddr;
11883
11884         if (status != 0) {
11885                 tester_test_failed();
11886                 return;
11887         }
11888
11889         tester_print("Device added");
11890
11891         /* If advertising is enabled on client that means we can stop here and
11892          * just wait for connection
11893          */
11894         if (test->client_enable_adv)
11895                 return;
11896
11897         central_bdaddr = hciemu_get_central_bdaddr(data->hciemu);
11898         if (!central_bdaddr) {
11899                 tester_warn("No central bdaddr");
11900                 tester_test_failed();
11901                 return;
11902         }
11903
11904         bthost = hciemu_client_get_host(data->hciemu);
11905         if (data->hciemu_type >= HCIEMU_TYPE_BREDRLE50)
11906                 bthost_hci_ext_connect(bthost, central_bdaddr,
11907                 BDADDR_LE_PUBLIC);
11908         else
11909                 bthost_hci_connect(bthost, central_bdaddr, BDADDR_LE_PUBLIC);
11910 }
11911
11912 static void test_connected_and_advertising(const void *test_data)
11913 {
11914         struct test_data *data = tester_get_data();
11915         const struct generic_data *test = data->test_data;
11916         const uint8_t *client_bdaddr;
11917         struct mgmt_cp_add_device cp;
11918
11919         tester_print("Registering %s notification",
11920                                         mgmt_evstr(MGMT_EV_DEVICE_CONNECTED));
11921
11922         test_add_condition(data);
11923         mgmt_register(data->mgmt_alt, MGMT_EV_DEVICE_CONNECTED,
11924                                 data->mgmt_index, le_connected_event,
11925                                 NULL, NULL);
11926
11927         client_bdaddr = hciemu_get_client_bdaddr(data->hciemu);
11928         if (!client_bdaddr) {
11929                 tester_warn("No client bdaddr");
11930                 tester_test_failed();
11931                 return;
11932         }
11933
11934         memset(&cp, 0, sizeof(cp));
11935         memcpy(&cp.addr.bdaddr, client_bdaddr, 6);
11936         cp.addr.type = BDADDR_LE_PUBLIC;
11937
11938         if (test->client_enable_adv)
11939                 cp.action = 0x02; /* Auto connect */
11940         else
11941                 cp.action = 0x01; /* Allow incoming connection */
11942
11943         mgmt_send(data->mgmt_alt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
11944                                                 sizeof(cp), &cp,
11945                                                 add_device_callback,
11946                                                 data, NULL);
11947 }
11948
11949 static void read_50_controller_cap_complete(uint8_t status, uint16_t length,
11950                                         const void *param, void *user_data)
11951 {
11952         struct test_data *data = user_data;
11953         const struct mgmt_rp_read_controller_cap *rp = param;
11954         const uint8_t *ptr = rp->cap;
11955         size_t offset = 0;
11956         uint8_t tag_len;
11957         uint8_t tag_type;
11958
11959         if (status || !param) {
11960                 tester_warn("Failed to read advertising features: %s (0x%02x)",
11961                                                 mgmt_errstr(status), status);
11962                 tester_test_failed();
11963         }
11964
11965         if (sizeof(rp->cap_len) + rp->cap_len != length) {
11966                 tester_warn("Controller capabilities malformed, size %zu != %u",
11967                                 sizeof(rp->cap_len) + rp->cap_len, length);
11968                 tester_test_failed();
11969         }
11970
11971         while (offset < rp->cap_len) {
11972                 tag_len = ptr[offset++];
11973                 tag_type = ptr[offset++];
11974
11975                 switch (tag_type) {
11976                 case MGMT_CAP_LE_TX_PWR:
11977                         if ((tag_len - sizeof(tag_type)) != 2) {
11978                                 tester_warn("TX power had unexpected length %d",
11979                                         tag_len);
11980                                 break;
11981                         }
11982                         tester_print("Expected Tx Power discovered: %d-%d",
11983                                         ptr[offset], ptr[offset+1]);
11984                         test_condition_complete(data);
11985                 }
11986
11987                 /* Step to the next entry */
11988                 offset += (tag_len - sizeof(tag_type));
11989         }
11990 }
11991
11992 static void test_50_controller_cap_response(const void *test_data)
11993 {
11994         struct test_data *data = tester_get_data();
11995
11996         test_add_condition(data);
11997
11998         mgmt_send(data->mgmt_alt, MGMT_OP_READ_CONTROLLER_CAP, data->mgmt_index,
11999                                                 0, NULL,
12000                                                 read_50_controller_cap_complete,
12001                                                 data, NULL);
12002 }
12003
12004 static const uint8_t suspend_state_param_disconnect[] = {
12005         0x01,
12006 };
12007
12008 static const uint8_t suspend_state_param_page_scan[] = {
12009         0x02,
12010 };
12011
12012 static const uint8_t resume_state_param_non_bt_wake[] = {
12013         0x00,
12014         0x00, 0x00, 0x0, 0x00, 0x00, 0x00,
12015         0x00
12016 };
12017
12018 static const struct generic_data suspend_resume_success_1 = {
12019         .setup_settings = settings_powered,
12020         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12021         .expect_alt_ev_param = suspend_state_param_disconnect,
12022         .expect_alt_ev_len = sizeof(suspend_state_param_disconnect),
12023 };
12024
12025 static void test_suspend_resume_success_1(const void *test_data)
12026 {
12027         struct test_data *data = tester_get_data();
12028         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12029         int err;
12030
12031         /* Triggers the suspend */
12032         err = vhci_set_force_suspend(vhci, true);
12033         if (err) {
12034                 tester_warn("Unable to enable the force_suspend");
12035                 tester_test_failed();
12036                 return;
12037         }
12038         test_command_generic(test_data);
12039 }
12040
12041 static const struct generic_data suspend_resume_success_2 = {
12042         .setup_settings = settings_powered,
12043         .expect_alt_ev = MGMT_EV_CONTROLLER_RESUME,
12044         .expect_alt_ev_param = resume_state_param_non_bt_wake,
12045         .expect_alt_ev_len = sizeof(resume_state_param_non_bt_wake),
12046 };
12047
12048 static void test_suspend_resume_success_2(const void *test_data)
12049 {
12050         struct test_data *data = tester_get_data();
12051         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12052         int err;
12053
12054         /* Triggers the suspend */
12055         err = vhci_set_force_suspend(vhci, true);
12056         if (err) {
12057                 tester_warn("Unable to enable the force_suspend");
12058                 tester_test_failed();
12059                 return;
12060         }
12061
12062         /* Triggers the resume */
12063         err = vhci_set_force_suspend(vhci, false);
12064         if (err) {
12065                 tester_warn("Unable to enable the force_suspend");
12066                 tester_test_failed();
12067                 return;
12068         }
12069         test_command_generic(test_data);
12070 }
12071
12072 static const struct generic_data suspend_resume_success_3 = {
12073         .setup_expect_hci_command = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
12074         .setup_expect_hci_param = le_add_to_accept_list_param,
12075         .setup_expect_hci_len = sizeof(le_add_to_accept_list_param),
12076         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12077         .expect_alt_ev_param = suspend_state_param_disconnect,
12078         .expect_alt_ev_len = sizeof(suspend_state_param_disconnect),
12079 };
12080
12081 static void setup_suspend_resume_success_3(const void *test_data)
12082 {
12083         struct test_data *data = tester_get_data();
12084         unsigned char param[] = { 0x01 };
12085
12086         /* Add Device 1 */
12087         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
12088                                         sizeof(add_device_success_param_3),
12089                                         add_device_success_param_3,
12090                                         setup_add_device_callback,
12091                                         NULL, NULL);
12092
12093         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
12094                                         sizeof(param), param,
12095                                         setup_powered_callback, NULL, NULL);
12096 }
12097
12098 static void test_suspend_resume_success_3(const void *test_data)
12099 {
12100         struct test_data *data = tester_get_data();
12101         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12102         int err;
12103
12104         /* Triggers the suspend */
12105         err = vhci_set_force_suspend(vhci, true);
12106         if (err) {
12107                 tester_warn("Unable to enable the force_suspend");
12108                 tester_test_failed();
12109                 return;
12110         }
12111         test_command_generic(test_data);
12112 }
12113
12114 static const struct generic_data suspend_resume_success_4 = {
12115         .setup_expect_hci_command = BT_HCI_CMD_LE_SET_EXT_ADV_ENABLE,
12116         .setup_expect_hci_param = set_ext_adv_on_set_adv_enable_param,
12117         .setup_expect_hci_len = sizeof(set_ext_adv_on_set_adv_enable_param),
12118         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12119         .expect_alt_ev_param = suspend_state_param_disconnect,
12120         .expect_alt_ev_len = sizeof(suspend_state_param_disconnect),
12121 };
12122
12123 static void setup_suspend_resume_success_4(const void *test_data)
12124 {
12125         struct test_data *data = tester_get_data();
12126         struct mgmt_cp_add_advertising *cp;
12127         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
12128         unsigned char param[] = { 0x01 };
12129
12130         cp = (struct mgmt_cp_add_advertising *) adv_param;
12131         setup_add_adv_param(cp, 1);
12132
12133         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
12134                                         sizeof(param), &param,
12135                                         NULL, NULL, NULL);
12136
12137         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
12138                                         sizeof(param), param,
12139                                         NULL, NULL, NULL);
12140
12141         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
12142                                         sizeof(adv_param), adv_param,
12143                                         setup_add_advertising_callback,
12144                                         NULL, NULL);
12145 }
12146
12147 static void test_suspend_resume_success_4(const void *test_data)
12148 {
12149         struct test_data *data = tester_get_data();
12150         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12151         int err;
12152
12153         test_command_generic(test_data);
12154
12155         /* Triggers the suspend */
12156         tester_print("Set the system into Suspend via force_suspend");
12157         err = vhci_set_force_suspend(vhci, true);
12158         if (err) {
12159                 tester_warn("Unable to enable the force_suspend");
12160                 tester_test_failed();
12161                 return;
12162         }
12163 }
12164
12165 static const struct generic_data suspend_resume_success_5 = {
12166         .setup_settings = settings_powered_connectable_bondable,
12167         .pin = pair_device_pin,
12168         .pin_len = sizeof(pair_device_pin),
12169         .client_pin = pair_device_pin,
12170         .client_pin_len = sizeof(pair_device_pin),
12171         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12172         .expect_alt_ev_param = suspend_state_param_disconnect,
12173         .expect_alt_ev_len = sizeof(suspend_state_param_disconnect),
12174 };
12175
12176 static void trigger_force_suspend(void *user_data)
12177 {
12178         struct test_data *data = tester_get_data();
12179         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12180         int err;
12181
12182         /* Triggers the suspend */
12183         tester_print("Set the system into Suspend via force_suspend");
12184         err = vhci_set_force_suspend(vhci, true);
12185         if (err) {
12186                 tester_warn("Unable to enable the force_suspend");
12187                 return;
12188         }
12189 }
12190
12191 static void trigger_force_resume(void *user_data)
12192 {
12193         struct test_data *data = tester_get_data();
12194         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12195         int err;
12196
12197         /* Triggers the suspend */
12198         tester_print("Set the system into Resume via force_suspend");
12199         err = vhci_set_force_suspend(vhci, false);
12200         if (err) {
12201                 tester_warn("Unable to disable the force_suspend");
12202                 return;
12203         }
12204 }
12205
12206 static void test_suspend_resume_success_5(const void *test_data)
12207 {
12208         test_pairing_acceptor(test_data);
12209         tester_wait(1, trigger_force_suspend, NULL);
12210 }
12211
12212 static const struct generic_data suspend_resume_success_6 = {
12213         .setup_settings = settings_powered_connectable_bondable_ssp,
12214         .client_enable_ssp = true,
12215         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12216         .expect_alt_ev_param = suspend_state_param_disconnect,
12217         .expect_alt_ev_len = sizeof(suspend_state_param_disconnect),
12218         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
12219         .expect_hci_func = client_bdaddr_param_func,
12220         .io_cap = 0x03, /* NoInputNoOutput */
12221         .client_io_cap = 0x03, /* NoInputNoOutput */
12222         .just_works = true,
12223 };
12224
12225 static const struct generic_data suspend_resume_success_7 = {
12226         .setup_settings = settings_powered,
12227         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12228         .expect_alt_ev_param = suspend_state_param_page_scan,
12229         .expect_alt_ev_len = sizeof(suspend_state_param_page_scan),
12230 };
12231
12232 static void test_suspend_resume_success_7(const void *test_data)
12233 {
12234         struct test_data *data = tester_get_data();
12235         struct vhci *vhci = hciemu_get_vhci(data->hciemu);
12236         int err;
12237
12238         /* Set Force Wakeup */
12239         err = vhci_set_force_wakeup(vhci, true);
12240         if (err) {
12241                 tester_warn("Unable to enable the force_wakeup");
12242                 tester_test_failed();
12243                 return;
12244         }
12245
12246         /* Triggers the suspend */
12247         err = vhci_set_force_suspend(vhci, true);
12248         if (err) {
12249                 tester_warn("Unable to enable the force_suspend");
12250                 tester_test_failed();
12251                 return;
12252         }
12253         test_command_generic(test_data);
12254 }
12255
12256 static const struct generic_data suspend_resume_success_8 = {
12257         .setup_settings = settings_powered_le,
12258         .send_opcode = MGMT_OP_START_DISCOVERY,
12259         .send_param = start_discovery_le_param,
12260         .send_len = sizeof(start_discovery_le_param),
12261         .expect_status = MGMT_STATUS_SUCCESS,
12262         .expect_param = start_discovery_le_param,
12263         .expect_len = sizeof(start_discovery_le_param),
12264         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_ENABLE,
12265         .expect_hci_param = start_discovery_valid_ext_scan_enable,
12266         .expect_hci_len = sizeof(start_discovery_valid_ext_scan_enable),
12267         .expect_alt_ev = MGMT_EV_CONTROLLER_SUSPEND,
12268         .expect_alt_ev_param = suspend_state_param_disconnect,
12269         .expect_alt_ev_len = sizeof(suspend_state_param_disconnect),
12270 };
12271
12272 static void test_suspend_resume_success_8(const void *test_data)
12273 {
12274         test_command_generic(test_data);
12275         tester_wait(1, trigger_force_suspend, NULL);
12276 }
12277
12278 static uint16_t settings_powered_le_discovery[] = { MGMT_OP_SET_LE,
12279                                                     MGMT_OP_SET_POWERED,
12280                                                     MGMT_OP_START_DISCOVERY,
12281                                                     0 };
12282
12283 static const struct generic_data suspend_resume_success_9 = {
12284         .setup_settings = settings_powered_le_discovery,
12285         .setup_discovery_param = start_discovery_bredrle_param,
12286         .setup_expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_ENABLE,
12287         .setup_expect_hci_param = stop_discovery_valid_ext_scan_disable,
12288         .setup_expect_hci_len = sizeof(stop_discovery_valid_ext_scan_disable),
12289         .expect_hci_command = BT_HCI_CMD_LE_SET_EXT_SCAN_ENABLE,
12290         .expect_hci_param = start_discovery_valid_ext_scan_enable,
12291         .expect_hci_len = sizeof(start_discovery_valid_ext_scan_enable),
12292         .expect_alt_ev = MGMT_EV_CONTROLLER_RESUME,
12293         .expect_alt_ev_param = resume_state_param_non_bt_wake,
12294         .expect_alt_ev_len = sizeof(resume_state_param_non_bt_wake),
12295 };
12296
12297 static void trigger_force_suspend_9(void *user_data)
12298 {
12299         trigger_force_suspend(user_data);
12300 }
12301
12302 static void setup_suspend_resume_success_9(const void *test_data)
12303 {
12304         setup_command_generic(test_data);
12305         tester_wait(1, trigger_force_suspend_9, NULL);
12306 }
12307
12308 static void test_suspend_resume_success_9(const void *test_data)
12309 {
12310         test_command_generic(test_data);
12311         tester_wait(2, trigger_force_resume, NULL);
12312 }
12313
12314 static const struct generic_data suspend_resume_success_10 = {
12315         .setup_settings = settings_powered_le,
12316         .expect_alt_ev = MGMT_EV_CONTROLLER_RESUME,
12317         .expect_alt_ev_param = resume_state_param_non_bt_wake,
12318         .expect_alt_ev_len = sizeof(resume_state_param_non_bt_wake),
12319 };
12320
12321 static void resume_event(uint16_t index, uint16_t length,
12322                                         const void *param, void *user_data)
12323 {
12324         struct test_data *data = tester_get_data();
12325         const struct mgmt_ev_controller_resume *ev = param;
12326
12327         mgmt_unregister(data->mgmt, data->mgmt_discov_ev_id);
12328
12329         if (length != sizeof(*ev)) {
12330                 tester_warn("Incorrect resume event length");
12331                 tester_setup_failed();
12332                 return;
12333         }
12334
12335         tester_print("New Controller Resume event received");
12336         test_condition_complete(data);
12337         tester_setup_complete();
12338 }
12339
12340
12341 static void setup_suspend_resume_success_10(const void *test_data)
12342 {
12343         struct test_data *data = tester_get_data();
12344         unsigned int id;
12345
12346         tester_print("Registering Controller Resume notification");
12347         id = mgmt_register(data->mgmt, MGMT_EV_CONTROLLER_RESUME,
12348                            data->mgmt_index, resume_event, NULL, NULL);
12349         /* Reuse the variable */
12350         data->mgmt_discov_ev_id = id;
12351         test_add_condition(data);
12352
12353         tester_wait(1, trigger_force_suspend, NULL);
12354         tester_wait(2, trigger_force_resume, NULL);
12355 }
12356
12357 static void test_suspend_resume_success_10(const void *test_data)
12358 {
12359         test_command_generic(test_data);
12360         tester_wait(1, trigger_force_suspend, NULL);
12361         tester_wait(2, trigger_force_resume, NULL);
12362 }
12363
12364 int main(int argc, char *argv[])
12365 {
12366         tester_init(&argc, &argv);
12367
12368         test_bredrle("Controller setup",
12369                                 NULL, NULL, controller_setup);
12370         test_bredr("Controller setup (BR/EDR-only)",
12371                                 NULL, NULL, controller_setup);
12372         test_le("Controller setup (LE)",
12373                                 NULL, NULL, controller_setup);
12374
12375         test_bredrle("Invalid command",
12376                                 &invalid_command_test,
12377                                 NULL, test_command_generic);
12378
12379         test_bredrle("Read version - Success",
12380                                 &read_version_success_test,
12381                                 NULL, test_command_generic);
12382         test_bredrle("Read version - Invalid parameters",
12383                                 &read_version_invalid_param_test,
12384                                 NULL, test_command_generic);
12385         test_bredrle("Read version - Invalid index",
12386                                 &read_version_invalid_index_test,
12387                                 NULL, test_command_generic);
12388         test_bredrle("Read commands - Invalid parameters",
12389                                 &read_commands_invalid_param_test,
12390                                 NULL, test_command_generic);
12391         test_bredrle("Read commands - Invalid index",
12392                                 &read_commands_invalid_index_test,
12393                                 NULL, test_command_generic);
12394         test_bredrle("Read index list - Invalid parameters",
12395                                 &read_index_list_invalid_param_test,
12396                                 NULL, test_command_generic);
12397         test_bredrle("Read index list - Invalid index",
12398                                 &read_index_list_invalid_index_test,
12399                                 NULL, test_command_generic);
12400         test_bredrle("Read info - Invalid parameters",
12401                                 &read_info_invalid_param_test,
12402                                 NULL, test_command_generic);
12403         test_bredrle("Read info - Invalid index",
12404                                 &read_info_invalid_index_test,
12405                                 NULL, test_command_generic);
12406         test_bredrle("Read unconfigured index list - Invalid parameters",
12407                                 &read_unconf_index_list_invalid_param_test,
12408                                 NULL, test_command_generic);
12409         test_bredrle("Read unconfigured index list - Invalid index",
12410                                 &read_unconf_index_list_invalid_index_test,
12411                                 NULL, test_command_generic);
12412         test_bredrle("Read configuration info - Invalid parameters",
12413                                 &read_config_info_invalid_param_test,
12414                                 NULL, test_command_generic);
12415         test_bredrle("Read configuration info - Invalid index",
12416                                 &read_config_info_invalid_index_test,
12417                                 NULL, test_command_generic);
12418         test_bredrle("Read extended index list - Invalid parameters",
12419                                 &read_ext_index_list_invalid_param_test,
12420                                 NULL, test_command_generic);
12421         test_bredrle("Read extended index list - Invalid index",
12422                                 &read_ext_index_list_invalid_index_test,
12423                                 NULL, test_command_generic);
12424
12425         test_bredrle("Set powered on - Success",
12426                                 &set_powered_on_success_test,
12427                                 NULL, test_command_generic);
12428         test_bredrle("Set powered on - Invalid parameters 1",
12429                                 &set_powered_on_invalid_param_test_1,
12430                                 NULL, test_command_generic);
12431         test_bredrle("Set powered on - Invalid parameters 2",
12432                                 &set_powered_on_invalid_param_test_2,
12433                                 NULL, test_command_generic);
12434         test_bredrle("Set powered on - Invalid parameters 3",
12435                                 &set_powered_on_invalid_param_test_3,
12436                                 NULL, test_command_generic);
12437         test_bredrle("Set powered on - Invalid index",
12438                                 &set_powered_on_invalid_index_test,
12439                                 NULL, test_command_generic);
12440         test_le("Set powered on - Privacy and Advertising",
12441                                 &set_powered_on_privacy_adv_test,
12442                                 NULL, test_command_generic);
12443
12444         test_bredrle("Set powered off - Success",
12445                                 &set_powered_off_success_test,
12446                                 NULL, test_command_generic);
12447         test_bredrle("Set powered off - Class of Device",
12448                                 &set_powered_off_class_test,
12449                                 setup_class, test_command_generic);
12450         test_bredrle("Set powered off - Invalid parameters 1",
12451                                 &set_powered_off_invalid_param_test_1,
12452                                 NULL, test_command_generic);
12453         test_bredrle("Set powered off - Invalid parameters 2",
12454                                 &set_powered_off_invalid_param_test_2,
12455                                 NULL, test_command_generic);
12456         test_bredrle("Set powered off - Invalid parameters 3",
12457                                 &set_powered_off_invalid_param_test_3,
12458                                 NULL, test_command_generic);
12459
12460         test_bredrle("Set connectable on - Success 1",
12461                                 &set_connectable_on_success_test_1,
12462                                 NULL, test_command_generic);
12463         test_bredrle("Set connectable on - Success 2",
12464                                 &set_connectable_on_success_test_2,
12465                                 NULL, test_command_generic);
12466         test_bredrle("Set connectable on - Invalid parameters 1",
12467                                 &set_connectable_on_invalid_param_test_1,
12468                                 NULL, test_command_generic);
12469         test_bredrle("Set connectable on - Invalid parameters 2",
12470                                 &set_connectable_on_invalid_param_test_2,
12471                                 NULL, test_command_generic);
12472         test_bredrle("Set connectable on - Invalid parameters 3",
12473                                 &set_connectable_on_invalid_param_test_3,
12474                                 NULL, test_command_generic);
12475         test_bredrle("Set connectable on - Invalid index",
12476                                 &set_connectable_on_invalid_index_test,
12477                                 NULL, test_command_generic);
12478
12479         test_le("Set connectable on (LE) - Success 1",
12480                                 &set_connectable_on_le_test_1,
12481                                 NULL, test_command_generic);
12482         test_le("Set connectable on (LE) - Success 2",
12483                                 &set_connectable_on_le_test_2,
12484                                 NULL, test_command_generic);
12485         test_le("Set connectable on (LE) - Success 3",
12486                                 &set_connectable_on_le_test_3,
12487                                 NULL, test_command_generic);
12488
12489         test_bredrle("Set connectable off - Success 1",
12490                                 &set_connectable_off_success_test_1,
12491                                 NULL, test_command_generic);
12492         test_bredrle("Set connectable off - Success 2",
12493                                 &set_connectable_off_success_test_2,
12494                                 NULL, test_command_generic);
12495         test_bredrle("Set connectable off - Success 3",
12496                                 &set_connectable_off_success_test_3,
12497                                 NULL, test_command_generic);
12498         test_bredrle("Set connectable off - Success 4",
12499                                 &set_connectable_off_success_test_4,
12500                                 setup_add_device, test_command_generic);
12501
12502         test_le("Set connectable off (LE) - Success 1",
12503                                 &set_connectable_off_le_test_1,
12504                                 NULL, test_command_generic);
12505         test_le("Set connectable off (LE) - Success 2",
12506                                 &set_connectable_off_le_test_2,
12507                                 NULL, test_command_generic);
12508         test_le("Set connectable off (LE) - Success 3",
12509                                 &set_connectable_off_le_test_3,
12510                                 NULL, test_command_generic);
12511         test_le("Set connectable off (LE) - Success 4",
12512                                 &set_connectable_off_le_test_4,
12513                                 NULL, test_command_generic);
12514
12515         test_bredrle("Set fast connectable on - Success 1",
12516                                 &set_fast_conn_on_success_test_1,
12517                                 NULL, test_command_generic);
12518         test_bredrle("Set fast connectable on - Success 2",
12519                                 &set_fast_conn_on_success_test_2,
12520                                 NULL, test_command_generic);
12521         test_bredrle("Set fast connectable on - Success 3",
12522                                 &set_fast_conn_on_success_test_3,
12523                                 NULL, test_command_generic);
12524         test_bredrle("Set fast connectable on - Invalid Params 1",
12525                                 &set_fast_conn_nval_param_test_1,
12526                                 NULL, test_command_generic);
12527         test_le("Set fast connectable on - Not Supported 1",
12528                                 &set_fast_conn_on_not_supported_test_1,
12529                                 NULL, test_command_generic);
12530
12531         test_bredrle("Set bondable on - Success",
12532                                 &set_bondable_on_success_test,
12533                                 NULL, test_command_generic);
12534         test_bredrle("Set bondable on - Invalid parameters 1",
12535                                 &set_bondable_on_invalid_param_test_1,
12536                                 NULL, test_command_generic);
12537         test_bredrle("Set bondable on - Invalid parameters 2",
12538                                 &set_bondable_on_invalid_param_test_2,
12539                                 NULL, test_command_generic);
12540         test_bredrle("Set bondable on - Invalid parameters 3",
12541                                 &set_bondable_on_invalid_param_test_3,
12542                                 NULL, test_command_generic);
12543         test_bredrle("Set bondable on - Invalid index",
12544                                 &set_bondable_on_invalid_index_test,
12545                                 NULL, test_command_generic);
12546
12547         test_bredrle("Set discoverable on - Invalid parameters 1",
12548                                 &set_discoverable_on_invalid_param_test_1,
12549                                 NULL, test_command_generic);
12550         test_bredrle("Set discoverable on - Invalid parameters 2",
12551                                 &set_discoverable_on_invalid_param_test_2,
12552                                 NULL, test_command_generic);
12553         test_bredrle("Set discoverable on - Invalid parameters 3",
12554                                 &set_discoverable_on_invalid_param_test_3,
12555                                 NULL, test_command_generic);
12556         test_bredrle("Set discoverable on - Invalid parameters 4",
12557                                 &set_discoverable_on_invalid_param_test_4,
12558                                 NULL, test_command_generic);
12559         test_bredrle("Set discoverable on - Not powered 1",
12560                                 &set_discoverable_on_not_powered_test_1,
12561                                 NULL, test_command_generic);
12562         test_bredrle("Set discoverable on - Not powered 2",
12563                                 &set_discoverable_on_not_powered_test_2,
12564                                 NULL, test_command_generic);
12565         test_bredrle("Set discoverable on - Rejected 1",
12566                                 &set_discoverable_on_rejected_test_1,
12567                                 NULL, test_command_generic);
12568         test_bredrle("Set discoverable on - Rejected 2",
12569                                 &set_discoverable_on_rejected_test_2,
12570                                 NULL, test_command_generic);
12571         test_bredrle("Set discoverable on - Rejected 3",
12572                                 &set_discoverable_on_rejected_test_3,
12573                                 NULL, test_command_generic);
12574         test_bredrle("Set discoverable on - Success 1",
12575                                 &set_discoverable_on_success_test_1,
12576                                 NULL, test_command_generic);
12577         test_bredrle("Set discoverable on - Success 2",
12578                                 &set_discoverable_on_success_test_2,
12579                                 NULL, test_command_generic);
12580         test_le("Set discoverable on (LE) - Success 1",
12581                                 &set_discov_on_le_success_1,
12582                                 NULL, test_command_generic);
12583         test_bredrle("Set discoverable off - Success 1",
12584                                 &set_discoverable_off_success_test_1,
12585                                 NULL, test_command_generic);
12586         test_bredrle("Set discoverable off - Success 2",
12587                                 &set_discoverable_off_success_test_2,
12588                                 NULL, test_command_generic);
12589         test_bredrle("Set limited discoverable on - Success 1",
12590                                 &set_limited_discov_on_success_1,
12591                                 NULL, test_command_generic);
12592         test_bredrle("Set limited discoverable on - Success 2",
12593                                 &set_limited_discov_on_success_2,
12594                                 NULL, test_command_generic);
12595         test_bredrle("Set limited discoverable on - Success 3",
12596                                 &set_limited_discov_on_success_3,
12597                                 NULL, test_command_generic);
12598         test_le("Set limited discoverable on (LE) - Success 1",
12599                                 &set_limited_discov_on_le_success_1,
12600                                 NULL, test_command_generic);
12601
12602         test_bredrle("Set link security on - Success 1",
12603                                 &set_link_sec_on_success_test_1,
12604                                 NULL, test_command_generic);
12605         test_bredrle("Set link security on - Success 2",
12606                                 &set_link_sec_on_success_test_2,
12607                                 NULL, test_command_generic);
12608         test_bredrle("Set link security on - Success 3",
12609                                 &set_link_sec_on_success_test_3,
12610                                 NULL, test_command_generic);
12611         test_bredrle("Set link security on - Invalid parameters 1",
12612                                 &set_link_sec_on_invalid_param_test_1,
12613                                 NULL, test_command_generic);
12614         test_bredrle("Set link security on - Invalid parameters 2",
12615                                 &set_link_sec_on_invalid_param_test_2,
12616                                 NULL, test_command_generic);
12617         test_bredrle("Set link security on - Invalid parameters 3",
12618                                 &set_link_sec_on_invalid_param_test_3,
12619                                 NULL, test_command_generic);
12620         test_bredrle("Set link security on - Invalid index",
12621                                 &set_link_sec_on_invalid_index_test,
12622                                 NULL, test_command_generic);
12623
12624         test_bredrle("Set link security off - Success 1",
12625                                 &set_link_sec_off_success_test_1,
12626                                 NULL, test_command_generic);
12627         test_bredrle("Set link security off - Success 2",
12628                                 &set_link_sec_off_success_test_2,
12629                                 NULL, test_command_generic);
12630
12631         test_bredrle("Set SSP on - Success 1",
12632                                 &set_ssp_on_success_test_1,
12633                                 NULL, test_command_generic);
12634         test_bredrle("Set SSP on - Success 2",
12635                                 &set_ssp_on_success_test_2,
12636                                 NULL, test_command_generic);
12637         test_bredrle("Set SSP on - Success 3",
12638                                 &set_ssp_on_success_test_3,
12639                                 NULL, test_command_generic);
12640         test_bredrle("Set SSP on - Invalid parameters 1",
12641                                 &set_ssp_on_invalid_param_test_1,
12642                                 NULL, test_command_generic);
12643         test_bredrle("Set SSP on - Invalid parameters 2",
12644                                 &set_ssp_on_invalid_param_test_2,
12645                                 NULL, test_command_generic);
12646         test_bredrle("Set SSP on - Invalid parameters 3",
12647                                 &set_ssp_on_invalid_param_test_3,
12648                                 NULL, test_command_generic);
12649         test_bredrle("Set SSP on - Invalid index",
12650                                 &set_ssp_on_invalid_index_test,
12651                                 NULL, test_command_generic);
12652
12653         test_bredrle("Set Secure Connections on - Success 1",
12654                                 &set_sc_on_success_test_1,
12655                                 NULL, test_command_generic);
12656         test_bredrle("Set Secure Connections on - Success 2",
12657                                 &set_sc_on_success_test_2,
12658                                 NULL, test_command_generic);
12659         test_bredrle("Set Secure Connections on - Invalid params 1",
12660                                 &set_sc_on_invalid_param_test_1,
12661                                 NULL, test_command_generic);
12662         test_bredrle("Set Secure Connections on - Invalid params 2",
12663                                 &set_sc_on_invalid_param_test_2,
12664                                 NULL, test_command_generic);
12665         test_bredrle("Set Secure Connections on - Invalid params 3",
12666                                 &set_sc_on_invalid_param_test_3,
12667                                 NULL, test_command_generic);
12668         test_bredrle("Set Secure Connections on - Invalid index",
12669                                 &set_sc_on_invalid_index_test,
12670                                 NULL, test_command_generic);
12671         test_bredr("Set Secure Connections on - Not supported 1",
12672                                 &set_sc_on_not_supported_test_1,
12673                                 NULL, test_command_generic);
12674         test_bredr("Set Secure Connections on - Not supported 2",
12675                                 &set_sc_on_not_supported_test_2,
12676                                 NULL, test_command_generic);
12677
12678         test_bredrle("Set Secure Connections Only on - Success 1",
12679                                 &set_sc_only_on_success_test_1,
12680                                 NULL, test_command_generic);
12681         test_bredrle("Set Secure Connections Only on - Success 2",
12682                                 &set_sc_only_on_success_test_2,
12683                                 NULL, test_command_generic);
12684
12685         test_hs("Set High Speed on - Success",
12686                                 &set_hs_on_success_test,
12687                                 NULL, test_command_generic);
12688         test_hs("Set High Speed on - Invalid parameters 1",
12689                                 &set_hs_on_invalid_param_test_1,
12690                                 NULL, test_command_generic);
12691         test_hs("Set High Speed on - Invalid parameters 2",
12692                                 &set_hs_on_invalid_param_test_2,
12693                                 NULL, test_command_generic);
12694         test_hs("Set High Speed on - Invalid parameters 3",
12695                                 &set_hs_on_invalid_param_test_3,
12696                                 NULL, test_command_generic);
12697         test_hs("Set High Speed on - Invalid index",
12698                                 &set_hs_on_invalid_index_test,
12699                                 NULL, test_command_generic);
12700
12701         test_bredrle("Set Low Energy on - Success 1",
12702                                 &set_le_on_success_test_1,
12703                                 NULL, test_command_generic);
12704         test_bredrle("Set Low Energy on - Success 2",
12705                                 &set_le_on_success_test_2,
12706                                 NULL, test_command_generic);
12707         test_bredrle("Set Low Energy on - Success 3",
12708                                 &set_le_on_success_test_3,
12709                                 NULL, test_command_generic);
12710         test_bredrle("Set Low Energy on - Invalid parameters 1",
12711                                 &set_le_on_invalid_param_test_1,
12712                                 NULL, test_command_generic);
12713         test_bredrle("Set Low Energy on - Invalid parameters 2",
12714                                 &set_le_on_invalid_param_test_2,
12715                                 NULL, test_command_generic);
12716         test_bredrle("Set Low Energy on - Invalid parameters 3",
12717                                 &set_le_on_invalid_param_test_3,
12718                                 NULL, test_command_generic);
12719         test_bredrle("Set Low Energy on - Invalid index",
12720                                 &set_le_on_invalid_index_test,
12721                                 NULL, test_command_generic);
12722
12723         test_bredrle("Set Advertising on - Success 1",
12724                                 &set_adv_on_success_test_1,
12725                                 NULL, test_command_generic);
12726         test_bredrle("Set Advertising on - Success 2",
12727                                 &set_adv_on_success_test_2,
12728                                 NULL, test_command_generic);
12729         test_bredrle("Set Advertising on - Rejected 1",
12730                                 &set_adv_on_rejected_test_1,
12731                                 NULL, test_command_generic);
12732
12733         test_bredrle("Set Advertising on - Appearance 1",
12734                                 &set_adv_on_appearance_test_1,
12735                                 setup_command_generic, test_command_generic);
12736
12737         test_bredrle("Set Advertising on - Local name 1",
12738                                 &set_adv_on_local_name_test_1,
12739                                 setup_command_generic, test_command_generic);
12740
12741         test_bredrle("Set Advertising on - Name + Appear 1",
12742                                 &set_adv_on_local_name_appear_test_1,
12743                                 setup_command_generic, test_command_generic);
12744
12745         test_bredrle("Set BR/EDR off - Success 1",
12746                                 &set_bredr_off_success_test_1,
12747                                 NULL, test_command_generic);
12748         test_bredrle("Set BR/EDR on - Success 1",
12749                                 &set_bredr_on_success_test_1,
12750                                 NULL, test_command_generic);
12751         test_bredrle("Set BR/EDR on - Success 2",
12752                                 &set_bredr_on_success_test_2,
12753                                 NULL, test_command_generic);
12754         test_bredr("Set BR/EDR off - Not Supported 1",
12755                                 &set_bredr_off_notsupp_test,
12756                                 NULL, test_command_generic);
12757         test_le("Set BR/EDR off - Not Supported 2",
12758                                 &set_bredr_off_notsupp_test,
12759                                 NULL, test_command_generic);
12760         test_bredrle("Set BR/EDR off - Rejected 1",
12761                                 &set_bredr_off_failure_test_1,
12762                                 NULL, test_command_generic);
12763         test_bredrle("Set BR/EDR off - Rejected 2",
12764                                 &set_bredr_off_failure_test_2,
12765                                 NULL, test_command_generic);
12766         test_bredrle("Set BR/EDR off - Invalid Parameters 1",
12767                                 &set_bredr_off_failure_test_3,
12768                                 NULL, test_command_generic);
12769
12770         test_bredr("Set Local Name - Success 1",
12771                                 &set_local_name_test_1,
12772                                 NULL, test_command_generic);
12773         test_bredr("Set Local Name - Success 2",
12774                                 &set_local_name_test_2,
12775                                 NULL, test_command_generic);
12776         test_bredr("Set Local Name - Success 3",
12777                                 &set_local_name_test_3,
12778                                 NULL, test_command_generic);
12779
12780         test_bredrle("Start Discovery - Not powered 1",
12781                                 &start_discovery_not_powered_test_1,
12782                                 NULL, test_command_generic);
12783         test_bredrle("Start Discovery - Invalid parameters 1",
12784                                 &start_discovery_invalid_param_test_1,
12785                                 NULL, test_command_generic);
12786         test_bredrle("Start Discovery - Not supported 1",
12787                                 &start_discovery_not_supported_test_1,
12788                                 NULL, test_command_generic);
12789         test_bredrle("Start Discovery - Success 1",
12790                                 &start_discovery_valid_param_test_1,
12791                                 NULL, test_command_generic);
12792         test_le("Start Discovery - Success 2",
12793                                 &start_discovery_valid_param_test_2,
12794                                 NULL, test_command_generic);
12795         test_bredrle("Start Discovery - Power Off 1",
12796                                 &start_discovery_valid_param_power_off_1,
12797                                 NULL, test_command_generic);
12798
12799         test_bredrle("Stop Discovery - Success 1",
12800                                 &stop_discovery_success_test_1,
12801                                 setup_start_discovery, test_command_generic);
12802         test_bredr("Stop Discovery - BR/EDR (Inquiry) Success 1",
12803                                 &stop_discovery_bredr_success_test_1,
12804                                 setup_start_discovery, test_command_generic);
12805         test_bredrle("Stop Discovery - Rejected 1",
12806                                 &stop_discovery_rejected_test_1,
12807                                 NULL, test_command_generic);
12808         test_bredrle("Stop Discovery - Invalid parameters 1",
12809                                 &stop_discovery_invalid_param_test_1,
12810                                 setup_start_discovery, test_command_generic);
12811
12812         test_bredrle("Start Service Discovery - Not powered 1",
12813                                 &start_service_discovery_not_powered_test_1,
12814                                 NULL, test_command_generic);
12815         test_bredrle("Start Service Discovery - Invalid parameters 1",
12816                                 &start_service_discovery_invalid_param_test_1,
12817                                 NULL, test_command_generic);
12818         test_bredrle("Start Service Discovery - Not supported 1",
12819                                 &start_service_discovery_not_supported_test_1,
12820                                 NULL, test_command_generic);
12821         test_bredrle("Start Service Discovery - Success 1",
12822                                 &start_service_discovery_valid_param_test_1,
12823                                 NULL, test_command_generic);
12824         test_le("Start Service Discovery - Success 2",
12825                                 &start_service_discovery_valid_param_test_2,
12826                                 NULL, test_command_generic);
12827
12828         test_bredrle("Set Device Class - Success 1",
12829                                 &set_dev_class_valid_param_test_1,
12830                                 NULL, test_command_generic);
12831         test_bredrle("Set Device Class - Success 2",
12832                                 &set_dev_class_valid_param_test_2,
12833                                 NULL, test_command_generic);
12834         test_bredrle("Set Device Class - Invalid parameters 1",
12835                                 &set_dev_class_invalid_param_test_1,
12836                                 NULL, test_command_generic);
12837
12838         test_bredrle("Add UUID - UUID-16 1",
12839                                 &add_uuid16_test_1,
12840                                 NULL, test_command_generic);
12841         test_bredrle("Add UUID - UUID-16 multiple 1",
12842                                 &add_multi_uuid16_test_1,
12843                                 setup_multi_uuid16, test_command_generic);
12844         test_bredrle("Add UUID - UUID-16 partial 1",
12845                                 &add_multi_uuid16_test_2,
12846                                 setup_multi_uuid16_2, test_command_generic);
12847         test_bredrle("Add UUID - UUID-32 1",
12848                                 &add_uuid32_test_1,
12849                                 NULL, test_command_generic);
12850         test_bredrle("Add UUID - UUID-32 multiple 1",
12851                                 &add_uuid32_multi_test_1,
12852                                 setup_multi_uuid32, test_command_generic);
12853         test_bredrle("Add UUID - UUID-32 partial 1",
12854                                 &add_uuid32_multi_test_2,
12855                                 setup_multi_uuid32_2, test_command_generic);
12856         test_bredrle("Add UUID - UUID-128 1",
12857                                 &add_uuid128_test_1,
12858                                 NULL, test_command_generic);
12859         test_bredrle("Add UUID - UUID-128 multiple 1",
12860                                 &add_uuid128_multi_test_1,
12861                                 setup_multi_uuid128, test_command_generic);
12862         test_bredrle("Add UUID - UUID-128 partial 1",
12863                                 &add_uuid128_multi_test_2,
12864                                 setup_multi_uuid128_2, test_command_generic);
12865         test_bredrle("Add UUID - UUID mix",
12866                                 &add_uuid_mix_test_1,
12867                                 setup_uuid_mix, test_command_generic);
12868
12869         /* MGMT_OP_REMOVE_UUID
12870          * Remove existing UUID.
12871          */
12872         test_bredrle("Remove UUID - Success 1",
12873                                 &remove_uuid_success_1,
12874                                 setup_multi_uuid16, test_command_generic);
12875         /* MGMT_OP_REMOVE_UUID
12876          * Remove all UUID by sending zero filled UUID
12877          */
12878         test_bredrle("Remove UUID - All UUID - Success 2",
12879                                 &remove_uuid_all_success_2,
12880                                 setup_multi_uuid16, test_command_generic);
12881         /* MGMT_OP_REMOVE_UUID
12882          * Remove UUID while powering off
12883          * Expect the 0x000000 for the class of device
12884          */
12885         test_bredrle("Remove UUID - Power Off - Success 3",
12886                                 &remove_uuid_power_off_success_3,
12887                                 setup_multi_uuid16_power_off,
12888                                 test_command_generic);
12889         /* MGMT_OP_REMOVE_UUID
12890          * Remove UUID while powering off and then powering on
12891          */
12892         test_bredrle("Remove UUID - Power Off and On - Success 4",
12893                                 &remove_uuid_power_off_on_success_4,
12894                                 setup_multi_uuid16_power_off_remove,
12895                                 test_command_generic);
12896         /* MGMT_OP_REMOVE_UUID
12897          * Remove UUID doesn't exist - Invalid parameter
12898          */
12899         test_bredrle("Remove UUID - Not Exist - Invalid Params 1",
12900                                 &remove_uuid_invalid_params_1,
12901                                 setup_multi_uuid16, test_command_generic);
12902
12903         test_bredrle("Load Link Keys - Empty List Success 1",
12904                                 &load_link_keys_success_test_1,
12905                                 NULL, test_command_generic);
12906         test_bredrle("Load Link Keys - Empty List Success 2",
12907                                 &load_link_keys_success_test_2,
12908                                 NULL, test_command_generic);
12909         test_bredrle("Load Link Keys - Invalid Parameters 1",
12910                                 &load_link_keys_invalid_params_test_1,
12911                                 NULL, test_command_generic);
12912         test_bredrle("Load Link Keys - Invalid Parameters 2",
12913                                 &load_link_keys_invalid_params_test_2,
12914                                 NULL, test_command_generic);
12915         test_bredrle("Load Link Keys - Invalid Parameters 3",
12916                                 &load_link_keys_invalid_params_test_3,
12917                                 NULL, test_command_generic);
12918
12919         test_bredrle("Load Long Term Keys - Success 1",
12920                                 &load_ltks_success_test_1,
12921                                 NULL, test_command_generic);
12922         test_bredrle("Load Long Term Keys - Success 2",
12923                                 &load_ltks_success_test_2,
12924                                 NULL, test_command_generic);
12925         test_bredrle("Load Long Term Keys - Success 3 (20 with count 1)",
12926                                 &load_ltks_success_test_3,
12927                                 setup_load_ltks_20_by_1, test_command_generic);
12928         test_bredrle("Load Long Term Keys - Success 4 (20 with count 20)",
12929                                 &load_ltks_success_test_4,
12930                                 NULL, test_command_generic);
12931         test_bredrle("Load Long Term Keys - Success 5 (Power On and 20 keys)",
12932                                 &load_ltks_success_test_5,
12933                                 NULL, test_command_generic);
12934         test_bredrle("Load Long Term Keys - Invalid Parameters 1",
12935                                 &load_ltks_invalid_params_test_1,
12936                                 NULL, test_command_generic);
12937         test_bredrle("Load Long Term Keys - Invalid Parameters 2",
12938                                 &load_ltks_invalid_params_test_2,
12939                                 NULL, test_command_generic);
12940         test_bredrle("Load Long Term Keys - Invalid Parameters 3",
12941                                 &load_ltks_invalid_params_test_3,
12942                                 NULL, test_command_generic);
12943         test_bredrle("Load Long Term Keys - Invalid Parameters 4",
12944                                 &load_ltks_invalid_params_test_4,
12945                                 NULL, test_command_generic);
12946
12947         test_bredrle("Set IO Capability - Invalid Params 1",
12948                                 &set_io_cap_invalid_param_test_1,
12949                                 NULL, test_command_generic);
12950
12951         test_bredrle("Pair Device - Not Powered 1",
12952                                 &pair_device_not_powered_test_1,
12953                                 NULL, test_command_generic);
12954         test_bredrle("Pair Device - Power off 1",
12955                                 &pair_device_power_off_test_1,
12956                                 NULL, test_command_generic);
12957         test_le("Pair Device - Incorrect transport reject 1",
12958                                 &pair_device_not_supported_test_1,
12959                                 NULL, test_command_generic);
12960         test_bredr("Pair Device - Incorrect transport reject 2",
12961                                 &pair_device_not_supported_test_2,
12962                                 NULL, test_command_generic);
12963         test_bredrle("Pair Device - Reject on not enabled transport 1",
12964                                 &pair_device_reject_transport_not_enabled_1,
12965                                 NULL, test_command_generic);
12966         test_bredrle("Pair Device - Reject on not enabled transport 2",
12967                                 &pair_device_reject_transport_not_enabled_2,
12968                                 NULL, test_command_generic);
12969         test_bredrle("Pair Device - Invalid Parameters 1",
12970                                 &pair_device_invalid_param_test_1,
12971                                 NULL, test_command_generic);
12972         test_bredrle("Pair Device - Invalid Parameters 2",
12973                                 &pair_device_invalid_param_test_2,
12974                                 NULL, test_command_generic);
12975         test_bredrle("Pair Device - Legacy Success 1",
12976                                 &pair_device_success_test_1,
12977                                 NULL, test_command_generic);
12978         test_bredrle("Pair Device - Legacy Non-bondable 1",
12979                                 &pair_device_legacy_nonbondable_1,
12980                                 NULL, test_command_generic);
12981         test_bredrle("Pair Device - Sec Mode 3 Success 1",
12982                                 &pair_device_success_test_2,
12983                                 NULL, test_command_generic);
12984         test_bredrle("Pair Device - Legacy Reject 1",
12985                                 &pair_device_reject_test_1,
12986                                 NULL, test_command_generic);
12987         test_bredrle("Pair Device - Legacy Reject 2",
12988                                 &pair_device_reject_test_2,
12989                                 NULL, test_command_generic);
12990         test_bredrle("Pair Device - Sec Mode 3 Reject 1",
12991                                 &pair_device_reject_test_3,
12992                                 NULL, test_command_generic);
12993         test_bredrle("Pair Device - Sec Mode 3 Reject 2",
12994                                 &pair_device_reject_test_4,
12995                                 NULL, test_command_generic);
12996         test_bredrle("Pair Device - SSP Just-Works Success 1",
12997                                 &pair_device_ssp_test_1,
12998                                 NULL, test_command_generic);
12999         test_bredrle("Pair Device - SSP Just-Works Success 2",
13000                                 &pair_device_ssp_test_2,
13001                                 NULL, test_command_generic);
13002         test_bredrle("Pair Device - SSP Just-Works Success 3",
13003                                 &pair_device_ssp_test_3,
13004                                 NULL, test_command_generic);
13005         test_bredrle("Pair Device - SSP Confirm Success 1",
13006                                 &pair_device_ssp_test_4,
13007                                 NULL, test_command_generic);
13008         test_bredrle("Pair Device - SSP Confirm Success 2",
13009                                 &pair_device_ssp_test_5,
13010                                 NULL, test_command_generic);
13011         test_bredrle("Pair Device - SSP Confirm Success 3",
13012                                 &pair_device_ssp_test_6,
13013                                 NULL, test_command_generic);
13014         test_bredrle("Pair Device - SSP Confirm Reject 1",
13015                                 &pair_device_ssp_reject_1,
13016                                 NULL, test_command_generic);
13017         test_bredrle("Pair Device - SSP Confirm Reject 2",
13018                                 &pair_device_ssp_reject_2,
13019                                 NULL, test_command_generic);
13020         test_bredrle("Pair Device - SSP Non-bondable 1",
13021                                 &pair_device_ssp_nonbondable_1,
13022                                 NULL, test_command_generic);
13023         test_bredrle("Pair Device - SMP over BR/EDR Success 1",
13024                                 &pair_device_smp_bredr_test_1,
13025                                 NULL, test_command_generic);
13026         test_bredrle("Pair Device - SMP over BR/EDR Success 2",
13027                                 &pair_device_smp_bredr_test_2,
13028                                 NULL, test_command_generic);
13029         test_le("Pair Device - LE Success 1",
13030                                 &pair_device_le_success_test_1,
13031                                 NULL, test_command_generic);
13032         test_le("Pair Device - LE Success 2",
13033                                 &pair_device_le_success_test_2,
13034                                 NULL, test_command_generic);
13035         test_le("Pair Device - LE Reject 1",
13036                                 &pair_device_le_reject_test_1,
13037                                 NULL, test_command_generic);
13038         test_le("Pair Device - LE SC Legacy 1",
13039                                 &pair_device_le_sc_legacy_test_1,
13040                                 NULL, test_command_generic);
13041         test_le("Pair Device - LE SC Success 1",
13042                                 &pair_device_le_sc_success_test_1,
13043                                 NULL, test_command_generic);
13044         test_le("Pair Device - LE SC Success 2",
13045                                 &pair_device_le_sc_success_test_2,
13046                                 NULL, test_command_generic);
13047         test_bredrle("Pair Device - LE SC Success 3",
13048                                 &pair_device_le_sc_success_test_3,
13049                                 NULL, test_command_generic);
13050
13051         test_bredrle("Pairing Acceptor - Legacy 1",
13052                                 &pairing_acceptor_legacy_1, NULL,
13053                                 test_pairing_acceptor);
13054         test_bredrle("Pairing Acceptor - Legacy 2",
13055                                 &pairing_acceptor_legacy_2, NULL,
13056                                 test_pairing_acceptor);
13057         test_bredrle("Pairing Acceptor - Legacy 3",
13058                                 &pairing_acceptor_legacy_3, NULL,
13059                                 test_pairing_acceptor);
13060         test_bredrle("Pairing Acceptor - Link Sec 1",
13061                                 &pairing_acceptor_linksec_1, NULL,
13062                                 test_pairing_acceptor);
13063         test_bredrle("Pairing Acceptor - Link Sec 2",
13064                                 &pairing_acceptor_linksec_2, NULL,
13065                                 test_pairing_acceptor);
13066         test_bredrle("Pairing Acceptor - SSP 1",
13067                                 &pairing_acceptor_ssp_1, setup_pairing_acceptor,
13068                                 test_pairing_acceptor);
13069         test_bredrle("Pairing Acceptor - SSP 2",
13070                                 &pairing_acceptor_ssp_2, setup_pairing_acceptor,
13071                                 test_pairing_acceptor);
13072         test_bredrle("Pairing Acceptor - SSP 3",
13073                                 &pairing_acceptor_ssp_3, setup_pairing_acceptor,
13074                                 test_pairing_acceptor);
13075         test_bredrle("Pairing Acceptor - SSP 4",
13076                                 &pairing_acceptor_ssp_4, setup_pairing_acceptor,
13077                                 test_pairing_acceptor);
13078         test_bredrle("Pairing Acceptor - SMP over BR/EDR 1",
13079                                 &pairing_acceptor_smp_bredr_1,
13080                                 setup_pairing_acceptor, test_pairing_acceptor);
13081         test_bredrle("Pairing Acceptor - SMP over BR/EDR 2",
13082                                 &pairing_acceptor_smp_bredr_2,
13083                                 setup_pairing_acceptor, test_pairing_acceptor);
13084         test_le("Pairing Acceptor - LE 1",
13085                                 &pairing_acceptor_le_1, setup_pairing_acceptor,
13086                                 test_pairing_acceptor);
13087         test_le("Pairing Acceptor - LE 2",
13088                                 &pairing_acceptor_le_2, setup_pairing_acceptor,
13089                                 test_pairing_acceptor);
13090         test_le("Pairing Acceptor - LE 3",
13091                                 &pairing_acceptor_le_3, setup_pairing_acceptor,
13092                                 test_pairing_acceptor);
13093         test_le("Pairing Acceptor - LE 4",
13094                                 &pairing_acceptor_le_4, setup_pairing_acceptor,
13095                                 test_pairing_acceptor);
13096         test_le("Pairing Acceptor - LE 5",
13097                                 &pairing_acceptor_le_5, setup_pairing_acceptor,
13098                                 test_pairing_acceptor);
13099
13100         test_bredrle("Unpair Device - Not Powered 1",
13101                                 &unpair_device_not_powered_test_1,
13102                                 NULL, test_command_generic);
13103         test_bredrle("Unpair Device - Invalid Parameters 1",
13104                                 &unpair_device_invalid_param_test_1,
13105                                 NULL, test_command_generic);
13106         test_bredrle("Unpair Device - Invalid Parameters 2",
13107                                 &unpair_device_invalid_param_test_2,
13108                                 NULL, test_command_generic);
13109
13110         test_bredrle("Disconnect - Invalid Parameters 1",
13111                                 &disconnect_invalid_param_test_1,
13112                                 NULL, test_command_generic);
13113
13114         test_bredrle("Block Device - Invalid Parameters 1",
13115                                 &block_device_invalid_param_test_1,
13116                                 NULL, test_command_generic);
13117
13118         test_bredrle("Unblock Device - Invalid Parameters 1",
13119                                 &unblock_device_invalid_param_test_1,
13120                                 NULL, test_command_generic);
13121
13122         test_le("Set Static Address - Success 1",
13123                                 &set_static_addr_success_test,
13124                                 NULL, test_command_generic);
13125         test_bredrle("Set Static Address - Success 2",
13126                                 &set_static_addr_success_test_2,
13127                                 NULL, test_command_generic);
13128         test_bredrle("Set Static Address - Failure 1",
13129                                 &set_static_addr_failure_test,
13130                                 NULL, test_command_generic);
13131         test_bredr("Set Static Address - Failure 2",
13132                                 &set_static_addr_failure_test_2,
13133                                 NULL, test_command_generic);
13134
13135         test_bredrle("Set Scan Parameters - Success",
13136                                 &set_scan_params_success_test,
13137                                 NULL, test_command_generic);
13138
13139         test_bredrle("Load IRKs - Success 1",
13140                                 &load_irks_success1_test,
13141                                 NULL, test_command_generic);
13142         test_bredrle("Load IRKs - Success 2",
13143                                 &load_irks_success2_test,
13144                                 NULL, test_command_generic);
13145         test_bredrle("Load IRKs - Invalid Parameters 1",
13146                                 &load_irks_nval_param1_test,
13147                                 NULL, test_command_generic);
13148         test_bredrle("Load IRKs - Invalid Parameters 2",
13149                                 &load_irks_nval_param2_test,
13150                                 NULL, test_command_generic);
13151         test_bredrle("Load IRKs - Invalid Parameters 3",
13152                                 &load_irks_nval_param3_test,
13153                                 NULL, test_command_generic);
13154         test_bredr("Load IRKs - Not Supported",
13155                                 &load_irks_not_supported_test,
13156                                 NULL, test_command_generic);
13157
13158         test_bredrle("Set Privacy - Success 1",
13159                                 &set_privacy_success_1_test,
13160                                 NULL, test_command_generic);
13161         test_bredrle("Set Privacy - Success 2 (Device Mode)",
13162                                 &set_privacy_success_2_test,
13163                                 NULL, test_command_generic);
13164         test_bredrle("Set Privacy - Rejected",
13165                                 &set_privacy_powered_test,
13166                                 NULL, test_command_generic);
13167         test_bredrle("Set Privacy - Invalid Parameters",
13168                                 &set_privacy_nval_param_test,
13169                                 NULL, test_command_generic);
13170
13171         test_bredrle("Get Clock Info - Success",
13172                                 &get_clock_info_succes1_test, NULL,
13173                                 test_command_generic_connect);
13174         test_bredrle("Get Clock Info - Fail (Power Off)",
13175                                 &get_clock_info_fail1_test, NULL,
13176                                 test_command_generic);
13177
13178         test_bredrle("Get Conn Info - Success",
13179                                 &get_conn_info_succes1_test, NULL,
13180                                 test_command_generic_connect);
13181         test_bredrle("Get Conn Info - Not Connected",
13182                                 &get_conn_info_ncon_test, NULL,
13183                                 test_command_generic);
13184         test_bredrle("Get Conn Info - Power off",
13185                                 &get_conn_info_power_off_test, NULL,
13186                                 test_command_generic_connect);
13187
13188         test_bredrle("Load Connection Parameters - Invalid Params 1",
13189                                 &load_conn_params_fail_1,
13190                                 NULL, test_command_generic);
13191
13192         test_bredrle("Add Device - Invalid Params 1",
13193                                 &add_device_fail_1,
13194                                 NULL, test_command_generic);
13195         test_bredrle("Add Device - Invalid Params 2",
13196                                 &add_device_fail_2,
13197                                 NULL, test_command_generic);
13198         test_bredrle("Add Device - Invalid Params 3",
13199                                 &add_device_fail_3,
13200                                 NULL, test_command_generic);
13201         test_bredrle("Add Device - Invalid Params 4",
13202                                 &add_device_fail_4,
13203                                 NULL, test_command_generic);
13204         test_bredrle("Add Device - Success 1",
13205                                 &add_device_success_1,
13206                                 NULL, test_command_generic);
13207         test_bredrle("Add Device - Success 2",
13208                                 &add_device_success_2,
13209                                 NULL, test_command_generic);
13210         test_bredrle("Add Device - Success 3",
13211                                 &add_device_success_3,
13212                                 NULL, test_command_generic);
13213         test_bredrle("Add Device - Success 4",
13214                                 &add_device_success_4,
13215                                 NULL, test_command_generic);
13216         test_bredrle("Add Device - Success 5",
13217                                 &add_device_success_5,
13218                                 NULL, test_command_generic);
13219
13220         test_bredrle("Remove Device - Invalid Params 1",
13221                                 &remove_device_fail_1,
13222                                 NULL, test_command_generic);
13223         test_bredrle("Remove Device - Invalid Params 2",
13224                                 &remove_device_fail_2,
13225                                 NULL, test_command_generic);
13226         test_bredrle("Remove Device - Invalid Params 3",
13227                                 &remove_device_fail_3,
13228                                 NULL, test_command_generic);
13229         test_bredrle("Remove Device - Success 1",
13230                                 &remove_device_success_1,
13231                                 setup_add_device, test_command_generic);
13232         test_bredrle("Remove Device - Success 2",
13233                                 &remove_device_success_2,
13234                                 setup_add_device, test_command_generic);
13235         test_bredrle("Remove Device - Success 3",
13236                                 &remove_device_success_3,
13237                                 setup_add_device, test_remove_device);
13238         test_le("Remove Device - Success 4",
13239                                 &remove_device_success_4,
13240                                 setup_add_device, test_remove_device);
13241         test_le("Remove Device - Success 5",
13242                                 &remove_device_success_5,
13243                                 setup_add_device, test_remove_device);
13244         /* MGMT_OP_REMOVE_DEVICE
13245          * Remove all devices
13246          */
13247         test_bredrle50("Remove Device - Success 6 - All Devices",
13248                                 &remove_device_success_6,
13249                                 setup_add_device, test_remove_device);
13250
13251         test_bredrle("Read Advertising Features - Invalid parameters",
13252                                 &read_adv_features_invalid_param_test,
13253                                 NULL, test_command_generic);
13254         test_bredrle("Read Advertising Features - Invalid index",
13255                                 &read_adv_features_invalid_index_test,
13256                                 NULL, test_command_generic);
13257         test_bredrle("Read Advertising Features - Success 1 (No instance)",
13258                                 &read_adv_features_success_1,
13259                                 NULL, test_command_generic);
13260         test_bredrle("Read Advertising Features - Success 2 (One instance)",
13261                                 &read_adv_features_success_2,
13262                                 setup_add_advertising,
13263                                 test_command_generic);
13264
13265         test_bredrle("Add Advertising - Failure: LE off",
13266                                         &add_advertising_fail_1,
13267                                         NULL, test_command_generic);
13268         test_bredrle("Add Advertising - Invalid Params 1 (AD too long)",
13269                                         &add_advertising_fail_2,
13270                                         NULL, test_command_generic);
13271         test_bredrle("Add Advertising - Invalid Params 2 (Malformed len)",
13272                                         &add_advertising_fail_3,
13273                                         NULL, test_command_generic);
13274         test_bredrle("Add Advertising - Invalid Params 3 (Malformed len)",
13275                                         &add_advertising_fail_4,
13276                                         NULL, test_command_generic);
13277         test_bredrle("Add Advertising - Invalid Params 4 (Malformed len)",
13278                                         &add_advertising_fail_5,
13279                                         NULL, test_command_generic);
13280         test_le("Add Advertising - Invalid Params 5 (AD too long)",
13281                                         &add_advertising_fail_6,
13282                                         NULL, test_command_generic);
13283         test_bredrle("Add Advertising - Invalid Params 6 (ScRsp too long)",
13284                                         &add_advertising_fail_7,
13285                                         NULL, test_command_generic);
13286         test_bredrle("Add Advertising - Invalid Params 7 (Malformed len)",
13287                                         &add_advertising_fail_8,
13288                                         NULL, test_command_generic);
13289         test_bredrle("Add Advertising - Invalid Params 8 (Malformed len)",
13290                                         &add_advertising_fail_9,
13291                                         NULL, test_command_generic);
13292         test_bredrle("Add Advertising - Invalid Params 9 (Malformed len)",
13293                                         &add_advertising_fail_10,
13294                                         NULL, test_command_generic);
13295         test_le("Add Advertising - Invalid Params 10 (ScRsp too long)",
13296                                         &add_advertising_fail_11,
13297                                         NULL, test_command_generic);
13298         test_bredrle("Add Advertising - Rejected (Timeout, !Powered)",
13299                                         &add_advertising_fail_12,
13300                                         NULL, test_command_generic);
13301         test_bredrle("Add Advertising - Success 1 (Powered, Add Adv Inst)",
13302                                         &add_advertising_success_1,
13303                                         NULL, test_command_generic);
13304         test_bredrle("Add Advertising - Success 2 (!Powered, Add Adv Inst)",
13305                                         &add_advertising_success_pwron_data,
13306                                         setup_add_advertising_not_powered,
13307                                         test_command_generic);
13308         test_bredrle("Add Advertising - Success 3 (!Powered, Adv Enable)",
13309                                         &add_advertising_success_pwron_enabled,
13310                                         setup_add_advertising_not_powered,
13311                                         test_command_generic);
13312         test_bredrle("Add Advertising - Success 4 (Set Adv on override)",
13313                                         &add_advertising_success_4,
13314                                         setup_add_advertising,
13315                                         test_command_generic);
13316         test_bredrle("Add Advertising - Success 5 (Set Adv off override)",
13317                                         &add_advertising_success_5,
13318                                         setup_set_and_add_advertising,
13319                                         test_command_generic);
13320         test_bredrle("Add Advertising - Success 6 (Scan Rsp Dta, Adv ok)",
13321                                         &add_advertising_success_6,
13322                                         NULL, test_command_generic);
13323         test_bredrle("Add Advertising - Success 7 (Scan Rsp Dta, Scan ok) ",
13324                                         &add_advertising_success_7,
13325                                         NULL, test_command_generic);
13326         test_bredrle("Add Advertising - Success 8 (Connectable Flag)",
13327                                         &add_advertising_success_8,
13328                                         NULL, test_command_generic);
13329         test_bredrle("Add Advertising - Success 9 (General Discov Flag)",
13330                                         &add_advertising_success_9,
13331                                         NULL, test_command_generic);
13332         test_bredrle("Add Advertising - Success 10 (Limited Discov Flag)",
13333                                         &add_advertising_success_10,
13334                                         NULL, test_command_generic);
13335         test_bredrle("Add Advertising - Success 11 (Managed Flags)",
13336                                         &add_advertising_success_11,
13337                                         NULL, test_command_generic);
13338         test_bredrle("Add Advertising - Success 12 (TX Power Flag)",
13339                                         &add_advertising_success_12,
13340                                         NULL, test_command_generic);
13341         test_bredrle("Add Advertising - Success 13 (ADV_SCAN_IND)",
13342                                         &add_advertising_success_13,
13343                                         NULL, test_command_generic);
13344         test_bredrle("Add Advertising - Success 14 (ADV_NONCONN_IND)",
13345                                         &add_advertising_success_14,
13346                                         NULL, test_command_generic);
13347         test_bredrle("Add Advertising - Success 15 (ADV_IND)",
13348                                         &add_advertising_success_15,
13349                                         NULL, test_command_generic);
13350         test_bredrle("Add Advertising - Success 16 (Connectable -> on)",
13351                                         &add_advertising_success_16,
13352                                         setup_add_advertising,
13353                                         test_command_generic);
13354         test_bredrle("Add Advertising - Success 17 (Connectable -> off)",
13355                                         &add_advertising_success_17,
13356                                         setup_add_advertising_connectable,
13357                                         test_command_generic);
13358         /* Adv instances with a timeout do NOT survive a power cycle. */
13359         test_bredrle("Add Advertising - Success 18 (Power -> off, Remove)",
13360                                         &add_advertising_power_off,
13361                                         setup_add_advertising_timeout,
13362                                         test_command_generic);
13363         /* Adv instances without timeout survive a power cycle. */
13364         test_bredrle("Add Advertising - Success 19 (Power -> off, Keep)",
13365                                         &add_advertising_success_pwron_data,
13366                                         setup_add_advertising_power_cycle,
13367                                         test_command_generic);
13368         /* Changing an advertising instance while it is still being
13369          * advertised will immediately update the advertised data if
13370          * there is no other instance to switch to.
13371          */
13372         test_bredrle("Add Advertising - Success 20 (Add Adv override)",
13373                                         &add_advertising_success_18,
13374                                         setup_add_advertising,
13375                                         test_command_generic);
13376         /* An instance should be removed when its timeout has been reached.
13377          * Advertising will also be disabled if this was the last instance.
13378          */
13379         test_bredrle_full("Add Advertising - Success 21 (Timeout expires)",
13380                                         &add_advertising_timeout_expired,
13381                                         setup_add_advertising_timeout,
13382                                         test_command_generic, 3);
13383         /* LE off will clear (remove) all instances. */
13384         test_bredrle("Add Advertising - Success 22 (LE -> off, Remove)",
13385                                         &add_advertising_le_off,
13386                                         setup_add_advertising,
13387                                         test_command_generic);
13388
13389         test_bredrle("Add Advertising - Success (Empty ScRsp)",
13390                                          &add_advertising_empty_scrsp,
13391                                          setup_command_generic,
13392                                          test_command_generic);
13393
13394         test_bredrle("Add Advertising - Success (ScRsp only)",
13395                                         &add_advertising_scrsp_data_only_ok,
13396                                                 NULL, test_command_generic);
13397
13398         test_bredrle("Add Advertising - Invalid Params (ScRsp too long)",
13399                                 &add_advertising_scrsp_data_only_too_long,
13400                                                 NULL, test_command_generic);
13401
13402         test_bredrle("Add Advertising - Success (ScRsp appear)",
13403                                         &add_advertising_scrsp_appear_data_ok,
13404                                 setup_command_generic, test_command_generic);
13405
13406         test_bredrle("Add Advertising - Invalid Params (ScRsp appear long)",
13407                                 &add_advertising_scrsp_appear_data_too_long,
13408                                 setup_command_generic, test_command_generic);
13409
13410         test_bredrle("Add Advertising - Success (Appear is null)",
13411                                         &add_advertising_scrsp_appear_null,
13412                                                 NULL, test_command_generic);
13413
13414         test_bredrle("Add Advertising - Success (Name is null)",
13415                                          &add_advertising_no_name_set,
13416                                          NULL, test_command_generic);
13417
13418         test_bredrle("Add Advertising - Success (Complete name)",
13419                                         &add_advertising_name_fits_in_scrsp,
13420                                         setup_command_generic,
13421                                         test_command_generic);
13422
13423         test_bredrle("Add Advertising - Success (Shortened name)",
13424                                 &add_advertising_shortened_name_in_scrsp,
13425                                         setup_command_generic,
13426                                         test_command_generic);
13427
13428         test_bredrle("Add Advertising - Success (Short name)",
13429                                         &add_advertising_short_name_in_scrsp,
13430                                         setup_command_generic,
13431                                         test_command_generic);
13432
13433         test_bredrle("Add Advertising - Success (Name + data)",
13434                                          &add_advertising_name_data_ok,
13435                                          setup_command_generic,
13436                                          test_command_generic);
13437
13438         test_bredrle("Add Advertising - Invalid Params (Name + data)",
13439                                          &add_advertising_name_data_inv,
13440                                          setup_command_generic,
13441                                          test_command_generic);
13442
13443         test_bredrle("Add Advertising - Success (Name+data+appear)",
13444                                          &add_advertising_name_data_appear,
13445                                          setup_command_generic,
13446                                          test_command_generic);
13447
13448         test_le_full("Adv. connectable & connected (peripheral) - Success",
13449                                         &conn_peripheral_adv_connectable_test,
13450                                         setup_advertise_while_connected,
13451                                         test_connected_and_advertising, 10);
13452
13453         test_le_full("Adv. non-connectable & connected (peripheral) - Success",
13454                                 &conn_peripheral_adv_non_connectable_test,
13455                                 setup_advertise_while_connected,
13456                                 test_connected_and_advertising, 10);
13457
13458         test_le_full("Adv. connectable & connected (central) - Success",
13459                                         &conn_central_adv_connectable_test,
13460                                         setup_advertise_while_connected,
13461                                         test_connected_and_advertising, 10);
13462
13463         test_le_full("Adv. non-connectable & connected (central) - Success",
13464                                         &conn_central_adv_non_connectable_test,
13465                                         setup_advertise_while_connected,
13466                                         test_connected_and_advertising, 10);
13467
13468         test_bredrle("Remove Advertising - Invalid Params 1",
13469                                         &remove_advertising_fail_1,
13470                                         NULL, test_command_generic);
13471
13472         test_bredrle("Remove Advertising - Success 1",
13473                                                 &remove_advertising_success_1,
13474                                                 setup_add_advertising,
13475                                                 test_command_generic);
13476         test_bredrle("Remove Advertising - Success 2",
13477                                                 &remove_advertising_success_2,
13478                                                 setup_add_advertising,
13479                                                 test_command_generic);
13480
13481         /* When advertising two instances, the instances should be
13482          * advertised in a round-robin fashion.
13483          */
13484         test_bredrle("Multi Advertising - Success 1 (Instance Switch)",
13485                                         &multi_advertising_switch,
13486                                         setup_multi_adv,
13487                                         test_command_generic);
13488         /* Adding a new instance when one is already being advertised
13489          * will switch to the new instance after the first has reached
13490          * its duration. A long timeout has been set to
13491          */
13492         test_bredrle_full("Multi Advertising - Success 2 (Add Second Inst)",
13493                                         &multi_advertising_add_second,
13494                                         setup_add_advertising_duration,
13495                                         test_command_generic, 3);
13496
13497         test_bredr("Set appearance - BR/EDR only",
13498                                         &set_appearance_not_supported,
13499                                         NULL,
13500                                         test_command_generic);
13501
13502         test_bredrle("Set appearance - BR/EDR LE",
13503                                         &set_appearance_success,
13504                                         NULL,
13505                                         test_command_generic);
13506
13507         test_le("Set appearance - LE only",
13508                                         &set_appearance_success,
13509                                         NULL,
13510                                         test_command_generic);
13511
13512         test_bredrle("Read Ext Controller Info 1",
13513                                 &read_ext_ctrl_info1,
13514                                 NULL, test_command_generic);
13515
13516         test_bredrle("Read Ext Controller Info 2",
13517                                 &read_ext_ctrl_info2,
13518                                 setup_command_generic, test_command_generic);
13519
13520         test_bredrle("Read Ext Controller Info 3",
13521                                 &read_ext_ctrl_info3,
13522                                 setup_command_generic, test_command_generic);
13523
13524         test_bredrle("Read Ext Controller Info 4",
13525                                 &read_ext_ctrl_info4,
13526                                 setup_command_generic, test_command_generic);
13527
13528         test_bredrle("Read Ext Controller Info 5",
13529                                 &read_ext_ctrl_info5,
13530                                 setup_command_generic, test_command_generic);
13531
13532         test_bredrle("Read Local OOB Data - Not powered",
13533                                 &read_local_oob_not_powered_test,
13534                                 NULL, test_command_generic);
13535         test_bredrle("Read Local OOB Data - Invalid parameters",
13536                                 &read_local_oob_invalid_param_test,
13537                                 NULL, test_command_generic);
13538         test_bredrle("Read Local OOB Data - Invalid index",
13539                                 &read_local_oob_invalid_index_test,
13540                                 NULL, test_command_generic);
13541         test_bredr20("Read Local OOB Data - Legacy pairing",
13542                                 &read_local_oob_legacy_pairing_test,
13543                                 NULL, test_command_generic);
13544         test_bredrle("Read Local OOB Data - Success SSP",
13545                                 &read_local_oob_success_ssp_test,
13546                                 NULL, test_command_generic);
13547         test_bredrle("Read Local OOB Data - Success SC",
13548                                 &read_local_oob_success_sc_test,
13549                                 NULL, test_command_generic);
13550         test_bredrle("Read Local OOB Ext Data - Invalid index",
13551                                 &read_local_oob_ext_invalid_index_test,
13552                                 NULL, test_command_generic);
13553         test_bredr20("Read Local OOB Ext Data - Legacy pairing",
13554                                 &read_local_oob_ext_legacy_pairing_test,
13555                                 NULL, test_command_generic);
13556         test_bredrle("Read Local OOB Ext Data - Success SSP",
13557                                 &read_local_oob_ext_success_ssp_test,
13558                                 NULL, test_command_generic);
13559         test_bredrle("Read Local OOB Ext Data - Success SC",
13560                                 &read_local_oob_ext_success_sc_test,
13561                                 NULL, test_command_generic);
13562
13563         test_bredrle("Device Found - Advertising data - Zero padded",
13564                                 &device_found_gtag,
13565                                 NULL, test_device_found);
13566         test_bredrle("Device Found - Advertising data - Invalid field",
13567                                 &device_found_invalid_field,
13568                                 NULL, test_device_found);
13569
13570         test_bredrle50("Read Ext Advertising Features - Success 3 (PHY flags)",
13571                                 &read_adv_features_success_3,
13572                                 NULL, test_command_generic);
13573
13574         test_bredrle50("Add Ext Advertising - Invalid Params 1 (Multiple Phys)",
13575                                         &add_ext_advertising_fail_1,
13576                                         NULL, test_command_generic);
13577
13578         test_bredrle50("Add Ext Advertising - Invalid Params 2 (Multiple PHYs)",
13579                                         &add_ext_advertising_fail_2,
13580                                         NULL, test_command_generic);
13581
13582         test_bredrle50("Add Ext Advertising - Invalid Params 3 (Multiple PHYs)",
13583                                         &add_ext_advertising_fail_3,
13584                                         NULL, test_command_generic);
13585
13586         test_bredrle50("Add Ext Advertising - Invalid Params 4 (Multiple PHYs)",
13587                                         &add_ext_advertising_fail_4,
13588                                         NULL, test_command_generic);
13589
13590         test_bredrle50("Add Ext Advertising - Success 1 (Powered, Add Adv Inst)",
13591                                                 &add_ext_advertising_success_1,
13592                                                 NULL, test_command_generic);
13593
13594
13595         test_bredrle50("Add Ext Advertising - Success 2 (!Powered, Add Adv Inst)",
13596                                         &add_ext_advertising_success_pwron_data,
13597                                         setup_add_advertising_not_powered,
13598                                         test_command_generic);
13599
13600         test_bredrle50("Add Ext Advertising - Success 3 (!Powered, Adv Enable)",
13601                                         &add_ext_advertising_success_pwron_enabled,
13602                                         setup_add_advertising_not_powered,
13603                                         test_command_generic);
13604
13605         test_bredrle50("Add Ext Advertising - Success 4 (Set Adv on override)",
13606                                         &add_ext_advertising_success_4,
13607                                         setup_add_advertising,
13608                                         test_command_generic);
13609
13610         test_bredrle50("Add Ext Advertising - Success 5 (Set Adv off override)",
13611                                         &add_ext_advertising_success_5,
13612                                         setup_set_and_add_advertising,
13613                                         test_command_generic);
13614
13615         test_bredrle50("Add Ext Advertising - Success 6 (Scan Rsp Dta, Adv ok)",
13616                                         &add_ext_advertising_success_6,
13617                                         NULL, test_command_generic);
13618
13619         test_bredrle50("Add Ext Advertising - Success 7 (Scan Rsp Dta, Scan ok) ",
13620                                         &add_ext_advertising_success_7,
13621                                         NULL, test_command_generic);
13622         test_bredrle50("Add Ext Advertising - Success 8 (Connectable Flag)",
13623                                         &add_ext_advertising_success_8,
13624                                         NULL, test_command_generic);
13625
13626         test_bredrle50("Add Ext Advertising - Success 9 (General Discov Flag)",
13627                                         &add_ext_advertising_success_9,
13628                                         NULL, test_command_generic);
13629
13630         test_bredrle50("Add Ext Advertising - Success 10 (Limited Discov Flag)",
13631                                         &add_ext_advertising_success_10,
13632                                         NULL, test_command_generic);
13633
13634         test_bredrle50("Add Ext Advertising - Success 11 (Managed Flags)",
13635                                         &add_ext_advertising_success_11,
13636                                         NULL, test_command_generic);
13637
13638         test_bredrle50("Add Ext Advertising - Success 12 (TX Power Flag)",
13639                                         &add_ext_advertising_success_12,
13640                                         NULL, test_command_generic);
13641
13642         test_bredrle50("Add Ext Advertising - Success 13 (ADV_SCAN_IND)",
13643                                         &add_ext_advertising_success_13,
13644                                         NULL, test_command_generic);
13645
13646         test_bredrle50("Add Ext Advertising - Success 14 (ADV_NONCONN_IND)",
13647                                         &add_ext_advertising_success_14,
13648                                         NULL, test_command_generic);
13649
13650         test_bredrle50("Add Ext Advertising - Success 15 (ADV_IND)",
13651                                         &add_ext_advertising_success_15,
13652                                         NULL, test_command_generic);
13653
13654         test_bredrle50("Add Ext Advertising - Success 16 (Connectable -> on)",
13655                                         &add_ext_advertising_success_16,
13656                                         setup_add_advertising,
13657                                         test_command_generic);
13658
13659         test_bredrle50("Add Ext Advertising - Success 17 (Connectable -> off)",
13660                                         &add_ext_advertising_success_17,
13661                                         setup_add_advertising_connectable,
13662                                         test_command_generic);
13663
13664         /* Changing an advertising instance while it is still being
13665          * advertised will immediately update the advertised data if
13666          * there is no other instance to switch to.
13667          */
13668         test_bredrle50("Add Ext Advertising - Success 20 (Add Adv override)",
13669                                         &add_ext_advertising_success_18,
13670                                         setup_add_advertising,
13671                                         test_command_generic);
13672
13673         /* An instance should be removed when its timeout has been reached.
13674          * Advertising will also be disabled if this was the last instance.
13675          */
13676         test_bredrle50_full("Add Ext Advertising - Success 21 (Timeout expires)",
13677                                         &add_ext_advertising_timeout_expired,
13678                                         setup_add_advertising_timeout,
13679                                         test_command_generic, 3);
13680
13681         /* LE off will clear (remove) all instances. */
13682         test_bredrle50("Add Ext Advertising - Success 22 (LE -> off, Remove)",
13683                                         &add_ext_advertising_le_off,
13684                                         setup_add_advertising,
13685                                         test_command_generic);
13686
13687         test_bredrle50("Add Ext Advertising - Success (Empty ScRsp)",
13688                                          &add_ext_advertising_empty_scrsp,
13689                                          setup_command_generic,
13690                                          test_command_generic);
13691
13692         test_bredrle50("Add Ext Advertising - Success (ScRsp only)",
13693                                         &add_ext_advertising_scrsp_data_only_ok,
13694                                                 NULL, test_command_generic);
13695
13696         test_bredrle50("Add Ext Advertising - Invalid Params (ScRsp too long)",
13697                                 &add_ext_advertising_scrsp_data_only_too_long,
13698                                                 NULL, test_command_generic);
13699
13700         test_bredrle50("Add Ext Advertising - Success (ScRsp appear)",
13701                                         &add_ext_advertising_scrsp_appear_data_ok,
13702                                 setup_command_generic, test_command_generic);
13703
13704         test_bredrle50("Add Ext Advertising - Invalid Params (ScRsp appear long)",
13705                                 &add_ext_advertising_scrsp_appear_data_too_long,
13706                                 setup_command_generic, test_command_generic);
13707
13708         test_bredrle50("Add Ext Advertising - Success (Appear is null)",
13709                                         &add_ext_advertising_scrsp_appear_null,
13710                                                 NULL, test_command_generic);
13711
13712         test_bredrle50("Add Ext Advertising - Success (Name is null)",
13713                                          &add_ext_advertising_no_name_set,
13714                                          NULL, test_command_generic);
13715
13716         test_bredrle50("Add Ext Advertising - Success (Complete name)",
13717                                         &add_ext_advertising_name_fits_in_scrsp,
13718                                         setup_command_generic,
13719                                         test_command_generic);
13720
13721         test_bredrle50("Add Ext Advertising - Success (Shortened name)",
13722                                 &add_ext_advertising_shortened_name_in_scrsp,
13723                                         setup_command_generic,
13724                                         test_command_generic);
13725
13726         test_bredrle50("Add Ext Advertising - Success (Short name)",
13727                                         &add_ext_advertising_shortened_name_in_scrsp,
13728                                         setup_command_generic,
13729                                         test_command_generic);
13730
13731         test_bredrle50("Add Ext Advertising - Success (Name + data)",
13732                                          &add_ext_advertising_name_data_ok,
13733                                          setup_command_generic,
13734                                          test_command_generic);
13735
13736         test_bredrle50("Add Ext Advertising - Invalid Params (Name + data)",
13737                                          &add_ext_advertising_name_data_inv,
13738                                          setup_command_generic,
13739                                          test_command_generic);
13740
13741         test_bredrle50("Add Ext Advertising - Success (Name+data+appear)",
13742                                          &add_ext_advertising_name_data_appear,
13743                                          setup_command_generic,
13744                                          test_command_generic);
13745
13746         test_bredrle50("Add Ext Advertising - Success (PHY -> 1M)",
13747                                         &add_ext_advertising_success_1m,
13748                                         NULL, test_command_generic);
13749
13750         test_bredrle50("Add Ext Advertising - Success (PHY -> 2M)",
13751                                         &add_ext_advertising_success_2m,
13752                                         NULL, test_command_generic);
13753
13754         test_bredrle50("Add Ext Advertising - Success (PHY -> Coded)",
13755                                         &add_ext_advertising_success_coded,
13756                                         NULL, test_command_generic);
13757
13758         test_bredrle50("Add Ext Advertising - Success (Ext Pdu Scannable)",
13759                                         &add_ext_advertising_success_scannable,
13760                                         NULL, test_command_generic);
13761
13762         test_bredrle50("Add Ext Advertising - Success (Ext Pdu Connectable)",
13763                                         &add_ext_advertising_success_connectable,
13764                                         NULL, test_command_generic);
13765
13766         /* In Ext pdu it shall not be both scannable and connectable */
13767         test_bredrle50("Add Ext Advertising - Success (Ext Pdu Conn Scan)",
13768                                         &add_ext_advertising_success_conn_scan,
13769                                         NULL, test_command_generic);
13770
13771         test_bredrle50("Add Ext Advertising - Success (1m Connectable -> on)",
13772                                         &add_ext_advertising_conn_on_1m,
13773                                         setup_add_advertising_1m,
13774                                         test_command_generic);
13775
13776         test_bredrle50("Add Ext Advertising - Success (1m Connectable -> off)",
13777                                         &add_ext_advertising_conn_off_1m,
13778                                         setup_add_advertising_connectable_1m,
13779                                         test_command_generic);
13780
13781         test_bredrle50("Remove Ext Advertising - Invalid Params 1",
13782                                         &remove_ext_advertising_fail_1,
13783                                         NULL, test_command_generic);
13784
13785         test_bredrle50("Remove Ext Advertising - Success 1",
13786                                                 &remove_ext_advertising_success_1,
13787                                                 setup_add_advertising,
13788                                                 test_command_generic);
13789
13790         test_bredrle50("Remove Ext Advertising - Success 2",
13791                                                 &remove_ext_advertising_success_2,
13792                                                 setup_add_advertising,
13793                                                 test_command_generic);
13794
13795         /* When advertising two instances, the instances should be
13796          * advertised in a round-robin fashion.
13797          */
13798         test_bredrle50("Multi Ext Advertising - Success 1",
13799                                         &multi_ext_advertising,
13800                                         setup_multi_adv,
13801                                         test_command_generic);
13802
13803         /* Adding a new instance when one is already being advertised
13804          * will switch to the new instance after the first has reached
13805          * its duration. A long timeout has been set to
13806          */
13807         test_bredrle50_full("Multi Ext Advertising - Success 2 (Add Second Inst)",
13808                                         &multi_ext_advertising_add_second,
13809                                         setup_add_advertising_duration,
13810                                         test_command_generic, 3);
13811         /* Multi Ext Advertising
13812          * Setup: Power on and the first ext advertising
13813          * Run: Add the second ext advertising
13814          * Expect: The second ext advertising is added.
13815          */
13816         test_bredrle50("Multi Ext Advertising - Success 3 (Add 2 Advs)",
13817                                         &multi_ext_advertising_add_second_2,
13818                                         setup_add_advertising,
13819                                         test_command_generic);
13820
13821         /* Multi Ext Advertising
13822          * Setup: Power on and add two ext advertising
13823          * Run: Remove the advertising
13824          * Expect: Received the removed event
13825          */
13826         test_bredrle50("Multi Ext Advertising - Success 4 (Remove Adv)",
13827                                         &multi_ext_advertising_remove,
13828                                         setup_add_2_advertisings,
13829                                         test_command_generic);
13830
13831         /* Multi Ext Advertising
13832          * Setup: Power on and add max advertisings
13833          * Run: Remove all advertisings
13834          * Expect:
13835          */
13836         test_bredrle50("Multi Ext Advertising - Success 5 (Remove all)",
13837                                         &multi_ext_advertising_remove_all,
13838                                         setup_add_2_advertisings,
13839                                         test_command_generic);
13840
13841         /* Multi Ext Advertising
13842          * Setup: Add multiple advertising before power on
13843          * Run: Power on
13844          * Expect: All advertising are set
13845          */
13846         test_bredrle50("Multi Ext Advertising - Success 6 (Add w/o power on)",
13847                                         &multi_ext_advertising_add_no_power,
13848                                         setup_add_2_advertisings_no_power,
13849                                         test_command_generic);
13850
13851         /* Multi Ext Advertising
13852          * Setup: Power on and add max advertisings
13853          * Run: Add another advertising
13854          * Expect: Received error - Invalid Parameter
13855          */
13856         test_bredrle50("Multi Ext Advertising - Fail (Add MAX)",
13857                                         &multi_ext_advertising_add_adv_4,
13858                                         setup_add_2_advertisings,
13859                                         test_command_generic);
13860
13861         test_bredrle50("Get PHY Success", &get_phy_success,
13862                                         NULL, test_command_generic);
13863
13864         test_bredrle50("Set PHY 2m Success", &set_phy_2m_success,
13865                                         NULL, test_command_generic);
13866
13867         test_bredrle50("Set PHY coded Succcess", &set_phy_coded_success,
13868                                         NULL, test_command_generic);
13869
13870         test_bredrle50("Set PHY 1m 2m coded Succcess", &set_phy_all_success,
13871                                         NULL, test_command_generic);
13872
13873         test_bredrle50("Set PHY 2m tx success", &set_phy_2m_tx_success,
13874                                         NULL, test_command_generic);
13875
13876         test_bredrle50("Set PHY 2m rx success", &set_phy_2m_rx_success,
13877                                         NULL, test_command_generic);
13878
13879         test_bredrle50("Set PHY Invalid Param", &set_phy_invalid_param,
13880                                         NULL, test_command_generic);
13881
13882         test_bredrle50("Start Discovery BREDR LE - (Ext Scan Enable)",
13883                                         &start_discovery_bredrle_ext_scan_enable,
13884                                         NULL,
13885                                         test_command_generic);
13886
13887         test_bredrle50("Start Discovery LE - (Ext Scan Enable)",
13888                                         &start_discovery_le_ext_scan_enable,
13889                                         NULL,
13890                                         test_command_generic);
13891
13892         test_bredrle50("Start Discovery LE - (Ext Scan Param)",
13893                                         &start_discovery_le_ext_scan_param,
13894                                         NULL,
13895                                         test_command_generic);
13896
13897         test_bredrle50("Stop Discovery - (Ext Scan Disable)",
13898                                 &stop_discovery_le_ext_scan_disable,
13899                                 setup_start_discovery, test_command_generic);
13900
13901         test_bredrle50("Start Discovery - (2m, Scan Param)",
13902                                 &start_discovery_le_2m_scan_param,
13903                                 setup_phy_configuration, test_command_generic);
13904
13905         test_bredrle50("Start Discovery - (coded, Scan Param)",
13906                                 &start_discovery_le_coded_scan_param,
13907                                 setup_phy_configuration, test_command_generic);
13908
13909         test_bredrle50("Start Discovery - (1m, 2m, coded, Scan Param)",
13910                                 &start_discovery_le_1m_coded_scan_param,
13911                                 setup_phy_configuration, test_command_generic);
13912
13913         test_bredrle50("Ext Device Found - Advertising data - Zero padded",
13914                                 &device_found_gtag,
13915                                 NULL, test_device_found);
13916
13917         test_bredrle50("Ext Device Found - Advertising data - Invalid field",
13918                                 &device_found_invalid_field,
13919                                 NULL, test_device_found);
13920
13921         test_bredrle50_full("Ext Adv. connectable & connected (peripheral)",
13922                                 &conn_peripheral_adv_connectable_test,
13923                                 setup_advertise_while_connected,
13924                                 test_connected_and_advertising, 10);
13925
13926         test_bredrle50_full("Ext Adv. non-connectable & connected (peripheral)",
13927                                 &conn_peripheral_adv_non_connectable_test,
13928                                 setup_advertise_while_connected,
13929                                 test_connected_and_advertising, 10);
13930
13931         test_bredrle50_full("Ext Adv. connectable & connected (central)",
13932                                 &conn_central_adv_connectable_test,
13933                                 setup_advertise_while_connected,
13934                                 test_connected_and_advertising, 10);
13935
13936         test_bredrle50_full("Ext Adv. non-connectable & connected (central)",
13937                                 &conn_central_adv_non_connectable_test,
13938                                 setup_advertise_while_connected,
13939                                 test_connected_and_advertising, 10);
13940
13941         test_bredrle("Read Controller Capabilities - Invalid parameters",
13942                                 &read_controller_cap_invalid_param_test,
13943                                 NULL, test_command_generic);
13944
13945         test_bredrle50("Read Controller Capabilities - (5.0) Success",
13946                                 &read_controller_cap_success,
13947                                 NULL, test_50_controller_cap_response);
13948
13949         test_bredrle("Ext Adv MGMT Params - Unpowered",
13950                                 &adv_params_fail_unpowered,
13951                                 setup_ext_adv_not_powered,
13952                                 test_command_generic);
13953
13954         test_bredrle("Ext Adv MGMT Params - Invalid parameters",
13955                                 &adv_params_fail_invalid_params,
13956                                 NULL, test_command_generic);
13957
13958         test_bredrle("Ext Adv MGMT Params - Success",
13959                                 &adv_params_success,
13960                                 NULL, test_command_generic);
13961
13962         test_bredrle50("Ext Adv MGMT Params - (5.0) Success",
13963                                 &adv_params_success_50,
13964                                 NULL, test_command_generic);
13965
13966         test_bredrle("Ext Adv MGMT - Data set without Params",
13967                                 &adv_data_fail_no_params,
13968                                 NULL, test_command_generic);
13969
13970         test_bredrle50("Ext Adv MGMT - AD Data (5.0) Invalid parameters",
13971                                 &adv_data_invalid_params,
13972                                 setup_ext_adv_params,
13973                                 test_command_generic);
13974
13975         test_bredrle50("Ext Adv MGMT - AD Data (5.0) Success",
13976                                 &adv_data_success,
13977                                 setup_ext_adv_params,
13978                                 test_command_generic);
13979
13980         test_bredrle50("zxcv Ext Adv MGMT - AD Scan Response (5.0) Success",
13981                                 &adv_scan_rsp_success,
13982                                 setup_ext_adv_params,
13983                                 test_command_generic);
13984
13985         /* MGMT_OP_SET_DEVICE_ID
13986          * Using Bluetooth SIG for source.
13987          */
13988         test_bredrle50("Set Device ID - Success 1",
13989                                 &set_dev_id_success_1,
13990                                 NULL,
13991                                 test_command_generic);
13992
13993         /* MGMT_OP_SET_DEVICE_ID
13994          * Using SB Implementer's Forum for source.
13995          */
13996         test_bredrle50("Set Device ID - Success 2",
13997                                 &set_dev_id_success_2,
13998                                 NULL,
13999                                 test_command_generic);
14000
14001         /* MGMT_OP_SET_DEVICE_ID
14002          * Disable DID with disable flag for source.
14003          */
14004         test_bredrle50("Set Device ID - Disable",
14005                                 &set_dev_id_disable,
14006                                 NULL,
14007                                 test_command_generic);
14008
14009         /* MGMT_OP_SET_DEVICE_ID
14010          * Power off, set device id, and power on.
14011          * Expect Write_Extended_Inquiry with device id when power on.
14012          */
14013         test_bredrle50("Set Device ID - Power off and Power on",
14014                                 &set_dev_id_power_off_on,
14015                                 setup_command_generic,
14016                                 test_command_generic);
14017
14018         /* MGMT_OP_SET_DEVICE_ID
14019          * SSP off, set device id, and SSP on.
14020          * Expect Write_Extended_Inquiry with device id when SSP on.
14021          */
14022         test_bredrle50("Set Device ID - SSP off and Power on",
14023                                 &set_dev_id_ssp_off_on,
14024                                 setup_command_generic,
14025                                 test_command_generic);
14026
14027         /* MGMT_OP_SET_DEVICE_ID
14028          * Invalid parameter
14029          */
14030         test_bredrle50("Set Device ID - Invalid Parameter",
14031                                 &set_dev_id_invalid_param,
14032                                 NULL,
14033                                 test_command_generic);
14034
14035         /* MGMT_OP_GET_DEVICE_FLAGS
14036          * Success
14037          */
14038         test_bredrle50("Get Device Flags - Success",
14039                                 &get_dev_flags_success,
14040                                 setup_get_dev_flags,
14041                                 test_command_generic);
14042
14043         /* MGMT_OP_GET_DEVICE_FLAGS
14044          * Fail - Invalid parameter
14045          */
14046         test_bredrle50("Get Device Flags - Invalid Parameter",
14047                                 &get_dev_flags_fail_1,
14048                                 setup_get_dev_flags,
14049                                 test_command_generic);
14050
14051         /* MGMT_OP_SET_DEVICE_FLAGS
14052          * Success
14053          */
14054         test_bredrle50("Set Device Flags - Success",
14055                                 &set_dev_flags_success,
14056                                 setup_get_dev_flags,
14057                                 test_command_generic);
14058
14059         /* MGMT_OP_SET_DEVICE_FLAGS
14060          * Invalid Parameter - Missing parameter
14061          */
14062         test_bredrle50("Set Device Flags - Invalid Parameter 1",
14063                                 &set_dev_flags_fail_1,
14064                                 setup_get_dev_flags,
14065                                 test_command_generic);
14066
14067         /* MGMT_OP_SET_DEVICE_FLAGS
14068          * Invalid Parameter - Not supported value
14069          */
14070         test_bredrle50("Set Device Flags - Invalid Parameter 2",
14071                                 &set_dev_flags_fail_2,
14072                                 setup_get_dev_flags,
14073                                 test_command_generic);
14074
14075         /* MGMT_OP_SET_DEVICE_FLAGS
14076          * Device not exist
14077          */
14078         test_bredrle50("Set Device Flags - Device not found",
14079                                 &set_dev_flags_fail_3,
14080                                 setup_get_dev_flags,
14081                                 test_command_generic);
14082
14083         /* Suspend/Resume
14084          * Setup : Power on and register Suspend Event
14085          * Run: Enable suspend via force_suspend
14086          * Expect: Receive the Suspend Event
14087          */
14088         test_bredrle50("Suspend - Success 1",
14089                                 &suspend_resume_success_1,
14090                                 NULL, test_suspend_resume_success_1);
14091
14092         /* Suspend/Resume
14093          * Setup : Power on and register Suspend Event
14094          * Run: Enable suspend, and then resume via force_suspend
14095          * Expect: Receive the Resume Event
14096          */
14097         test_bredrle50("Resume - Success 2",
14098                                 &suspend_resume_success_2,
14099                                 NULL, test_suspend_resume_success_2);
14100
14101         /* Suspend/Resume
14102          * Setup: Enable LL Privacy and power on
14103          * Run: Add new device, and enable suspend.
14104          * Expect: Receive the Suspend Event
14105          */
14106         test_bredrle50("Suspend - Success 3 (Device in WL)",
14107                                 &suspend_resume_success_3,
14108                                 setup_suspend_resume_success_3,
14109                                 test_suspend_resume_success_3);
14110
14111         /* Suspend/Resume
14112          * Setup: Start advertising and power on.
14113          * Run: Enable suspend
14114          * Expect: Receive the Suspend Event
14115          */
14116         test_bredrle50("Suspend - Success 4 (Advertising)",
14117                                 &suspend_resume_success_4,
14118                                 setup_suspend_resume_success_4,
14119                                 test_suspend_resume_success_4);
14120
14121         /* Suspend/Resume
14122          * Setup: Pair.
14123          * Run: Enable suspend
14124          * Expect: Receive the Suspend Event
14125          */
14126         test_bredrle("Suspend - Success 5 (Pairing - Legacy)",
14127                                 &suspend_resume_success_5, NULL,
14128                                 test_suspend_resume_success_5);
14129
14130         /* Suspend/Resume
14131          * Setup: Pair.
14132          * Run: Enable suspend
14133          * Expect: Receive the Suspend Event
14134          */
14135         test_bredrle("Suspend - Success 6 (Pairing - SSP)",
14136                                 &suspend_resume_success_6,
14137                                 setup_pairing_acceptor,
14138                                 test_suspend_resume_success_5);
14139
14140         /* Suspend/Resume
14141          * Setup : Power on and register Suspend Event
14142          * Run: Enable suspend via force_suspend
14143          * Expect: Receive the Suspend Event
14144          */
14145         test_bredrle50("Suspend - Success 7 (Suspend/Force Wakeup)",
14146                                 &suspend_resume_success_7,
14147                                 NULL, test_suspend_resume_success_7);
14148
14149         /* Suspend/Resume
14150          * Setup : Power on
14151          * Run: Start discover and enable suspend
14152          * Expect: Receive the Suspend Event
14153          */
14154         test_bredrle50_full("Suspend - Success 8 (Discovery/Suspend)",
14155                                 &suspend_resume_success_8,
14156                                 NULL, test_suspend_resume_success_8, 4);
14157
14158         /* Suspend/Resume
14159          * Setup : Power on, start discovery
14160          * Run: Start discover, enable suspend and resume.
14161          * Expect: Receive the Resume Event
14162          */
14163         test_bredrle50_full("Resume - Success 9 (Discovery/Suspend/Resume)",
14164                                 &suspend_resume_success_9,
14165                                 setup_suspend_resume_success_9,
14166                                 test_suspend_resume_success_9, 4);
14167
14168         /* Suspend/Resume
14169          * Setup : Power on
14170          * Run: Suspend, Resume, Suspend, and Resume
14171          * Expect:
14172          */
14173         test_bredrle50_full("Resume - Success 10 (Multiple Suspend/Resume)",
14174                                 &suspend_resume_success_10,
14175                                 setup_suspend_resume_success_10,
14176                                 test_suspend_resume_success_10, 6);
14177
14178         /* MGMT_OP_READ_EXP_FEATURE
14179          * Read Experimental features - success
14180          */
14181         test_bredrle50("Read Exp Feature - Success",
14182                                 &read_exp_feat_success,
14183                                 NULL, test_command_generic);
14184
14185         /* MGMT_OP_READ_EXP_FEATURE
14186          * Read Experimental features - success (Index None)
14187          */
14188         test_bredrle50("Read Exp Feature - Success (Index None)",
14189                                 &read_exp_feat_success_index_none,
14190                                 NULL, test_command_generic);
14191
14192         /* MGMT_OP_SET_EXP_FEATURE
14193          * Enable LL Privacy
14194          */
14195         test_bredrle50("Set Exp Feature - Enable LL Privacy",
14196                                 &set_exp_feat_enable_ll_privacy,
14197                                 setup_set_exp_feature_alt,
14198                                 test_command_generic);
14199
14200         /* MGMT_OP_SET_EXP_FEATURE
14201          * Offload Codec
14202          */
14203         test_bredrle50("Set Exp Feature - Offload Codec",
14204                                 &set_exp_feat_offload_codec,
14205                                 setup_set_exp_feature_alt,
14206                                 test_command_generic);
14207
14208         /* MGMT_OP_SET_EXP_FEATURE
14209          * Disable all features by sending zero UUID
14210          */
14211         test_bredrle50("Set Exp Feature - Disable all",
14212                                 &set_exp_feat_disable,
14213                                 NULL, test_command_generic);
14214
14215         /* MGMT_OP_SET_EXP_FEATURE
14216          * Rejected - If the power is on, the command should be rejected
14217          */
14218         test_bredrle50("Set Exp Feature - Rejected",
14219                                 &set_exp_feat_rejected,
14220                                 NULL, test_command_generic);
14221
14222         /* MGMT_OP_SET_EXP_FEATURE
14223          * Invalid parameter
14224          */
14225         test_bredrle50("Set Exp Feature - Invalid params",
14226                                 &set_exp_feat_invalid,
14227                                 NULL, test_command_generic);
14228
14229
14230         /* MGMT_OP_SET_EXP_FEATURE
14231          * Not Supported UUID
14232          */
14233         test_bredrle50("Set Exp Feature - Unknown feature",
14234                                 &set_exp_feat_unknown,
14235                                 NULL, test_command_generic);
14236
14237         /* LL Privacy
14238          * Setup: Enable LE and Power On
14239          * Run: Add new device
14240          * Expect: Device is added to the accept list
14241          */
14242         test_bredrle50("LL Privacy - Add Device 1 (Add to AL)",
14243                                 &ll_privacy_add_device_1,
14244                                 NULL, test_command_generic);
14245
14246         /* LL Privacy
14247          * Setup: Enable LL Privacy and add IRK of new device
14248          * Run: Add new device
14249          * Expect: Device is added to the resolving list
14250          */
14251         test_bredrle50("LL Privacy - Add Device 2 (Add to RL)",
14252                                 &ll_privacy_add_device_2,
14253                                 setup_ll_privacy_with_irk1,
14254                                 test_command_generic);
14255         /* LL Privacy
14256          * Setup: Enable LL Privacy and add IRK of new device
14257          * Run: Add new device
14258          * Expect: Device is added to the resolving list and resolving list
14259          *         is enabled
14260          */
14261         test_bredrle50("LL Privacy - Add Device 3 (Enable RL)",
14262                                 &ll_privacy_add_device_3,
14263                                 setup_ll_privacy_with_irk1,
14264                                 test_command_generic);
14265
14266         /* LL Privacy
14267          * Setup: Enable LL Privacy, add device1 with IRK, and add IRK of
14268          *        device2
14269          * Run: Add new device2
14270          * Expect: Device2 is added to the accept list
14271          */
14272         test_bredrle50("LL Privacy - Add Device 4 (2 Devices to AL)",
14273                                 &ll_privacy_add_device_4,
14274                                 setup_ll_privacy_dev1_and_irk2,
14275                                 test_command_generic);
14276
14277         /* LL Privacy
14278          * Setup: Enable LL Privacy, add device1 with IRK, and add IRK of
14279          *        device2
14280          * Run: Add new device2
14281          * Expect: Device2 is added to the resolv list
14282          */
14283         test_bredrle50("LL Privacy - Add Device 5 (2 Devices to RL)",
14284                                 &ll_privacy_add_device_5,
14285                                 setup_ll_privacy_dev1_and_irk2,
14286                                 test_command_generic);
14287
14288         /* LL Privacy
14289          * Setup: Enable LL Privacy, add 3 devices with IRKs, and add IRK of
14290          *        device4
14291          * Run: Add new device4
14292          * Expect: Device4 is added but failed to add to resolv list because
14293          *         btdev resolv list is full.
14294          */
14295         test_bredrle50("LL Privacy - Add Device 6 (RL is full)",
14296                                 &ll_privacy_add_device_6,
14297                                 setup_ll_privacy_2_devices_extra_rl,
14298                                 test_command_generic);
14299
14300         /* LL Privacy
14301          * Setup: Enable LL Privacy, add 2 devices with IRKs and 1 device
14302          *        without IRK, and add IRK for device4
14303          * Run: Add new device4
14304          * Expect: Device4 is added but failed to add to accept list, and it
14305          *         is removed from the resolv list.
14306          */
14307         test_bredrle50("LL Privacy - Add Device 7 (AL is full)",
14308                                 &ll_privacy_add_device_7,
14309                                 setup_ll_privacy_2_devices_extra_al,
14310                                 test_command_generic);
14311
14312         /* LL Privacy
14313          * Setup: Enable LL Privacy, and add advertising
14314          * Run: Add new device
14315          * Expect: Disable the advertising before adding new device to the
14316          *         accept list and resolving list
14317          */
14318         test_bredrle50("LL Privacy - Add Device 8 (Disable Adv)",
14319                                 &ll_privacy_add_device_8,
14320                                 setup_ll_privacy_adv, test_command_generic);
14321
14322         /* LL Privacy
14323          * Setup: Enable LL Privacy, and add 2 advertisings
14324          * Run: Add new device
14325          * Expect: Disable the advertising before adding new device to the
14326          *         accept list and resolving list
14327          */
14328         test_bredrle50("LL Privacy - Add Device 9 (Multi Adv)",
14329                                 &ll_privacy_add_device_9,
14330                                 setup_ll_privacy_2_advs, test_command_generic);
14331
14332         /* LL Privacy
14333          * Setup: Enable LL Privacy, and add 1 device and add 2 advertisings
14334          * Run: Add new device
14335          * Expect: Disable the advertising before adding new device to the
14336          *         accept list and resolving list
14337          */
14338         test_bredrle50("LL Privacy - Add Device 10 (Multi Dev and Multi Adv)",
14339                                 &ll_privacy_add_device_9,
14340                                 setup_ll_privacy_dev_2_advs,
14341                                 test_command_generic);
14342
14343         /* LL Privacy
14344          * Setup: Enable LL Privacy and add 2 devices and its IRK
14345          * Run: Remove one of devices
14346          * Expect: The device is removed from the accept list
14347          */
14348         test_bredrle50("LL Privacy - Remove Device 1 (Remove from AL)",
14349                                 &ll_privacy_remove_device_1,
14350                                 setup_ll_privacy_3_devices,
14351                                 test_command_generic);
14352         /* LL Privacy
14353          * Setup: Enable LL Privacy and add 2 devices and its IRK
14354          * Run: Remove one of devices
14355          * Expect: The device is removed from the resolving list
14356          */
14357         test_bredrle50("LL Privacy - Remove Device 2 (Remove from RL)",
14358                                 &ll_privacy_remove_device_2,
14359                                 setup_ll_privacy_3_devices,
14360                                 test_command_generic);
14361
14362         /* LL Privacy
14363          * Setup: Enable LL Privacy and add a device and its IRK
14364          * Run: Remove device
14365          * Expect: Device is removed and disable the resolving list before
14366          *         removing the device from the list.
14367          */
14368         test_bredrle50("LL Privacy - Remove Device 3 (Disable RL)",
14369                                 &ll_privacy_remove_device_3,
14370                                 setup_ll_privacy_3_devices,
14371                                 test_command_generic);
14372
14373         /* LL Privacy
14374          * Setup: Enable LL Privacy, add advertising and add device
14375          * Run: Remove the device
14376          * Expect: Disable the advertising before removing the device from the
14377          *         accept list and resolving list
14378          */
14379         test_bredrle50("LL Privacy - Remove Device 4 (Disable Adv)",
14380                                 &ll_privacy_remove_device_4,
14381                                 setup_ll_privacy_adv_3_devices,
14382                                 test_command_generic);
14383
14384         /* LL Privacy
14385          * Setup: Enable LL Privacy, add advertisings and add device
14386          * Run: Remove the device
14387          * Expect: Disable the advertising before removing the device from the
14388          *         accept list and resolving list
14389          */
14390         test_bredrle50("LL Privacy - Remove Device 5 (Multi Adv)",
14391                                 &ll_privacy_remove_device_5,
14392                                 setup_ll_privacy_adv_1_device_2_advs,
14393                                 test_command_generic);
14394
14395         /* LL Privacy
14396          * Setup: Enable LL Privacy
14397          * Check if the resolving list is disabled before the scan parameter is
14398          * changed.
14399          */
14400         test_bredrle50("LL Privacy - Start Discovery 1 (Disable RL)",
14401                                 &ll_privacy_start_discovery_ll_privacy_1,
14402                                 setup_ll_privacy_dev1_and_irk2,
14403                                 test_command_generic);
14404
14405         /* LL Privacy
14406          * Setup: Enable LL Privacy, Add 2 devices with IRKs and remove one of
14407          *        the device
14408          * Run: Start Discovery
14409          * Expect: Resolving list is disabled.
14410          */
14411         test_bredrle50("LL Privacy - Start Discovery 2 (Disable RL)",
14412                                 &ll_privacy_start_discovery_ll_privacy_2,
14413                                 setup_ll_privacy_device2_discovry,
14414                                 test_command_generic);
14415
14416         /* LL Privacy
14417          * Setup: Enable Privacy, LL Privacy, and enable advertising
14418          * Run: bthost scan the advertising
14419          * Expect: bthost receives the advertising with random address
14420          */
14421         test_bredrle50("LL Privacy - Advertising 1 (Scan Result)",
14422                                 &ll_privacy_advertising_1,
14423                                 setup_ll_privacy_enable_powered,
14424                                 test_ll_privacy_bthost_scan_report);
14425
14426         /* LL Privacy
14427          * Setup: Enable Privacy, LL Privacy, and enable advertising
14428          * Run: Connect from bthost
14429          * Expect: Pair success
14430          */
14431         test_bredrle50("LL Privacy - Acceptor 1",
14432                                 &ll_privacy_acceptor_1,
14433                                 setup_ll_privacy_add_adv,
14434                                 test_pairing_acceptor_ll_privacy_le_random);
14435
14436         /* LL Privacy
14437          * Setup: Enable Privacy, LL Privacy, and enable advertising
14438          * Run: Connect from bthost
14439          * Expect: Pair success
14440          */
14441         test_bredrle50("LL Privacy - Acceptor 2",
14442                                 &ll_privacy_acceptor_2,
14443                                 setup_ll_privacy_add_adv,
14444                                 test_pairing_acceptor_ll_privacy_le_random);
14445
14446         /* LL Privacy
14447          * Setup: Enable Privacy, LL Privacy
14448          * Run: Pair device
14449          * Expect: Pair success
14450          */
14451         test_bredrle50("LL Privacy - Pair 1",
14452                                 &ll_privacy_pair_1,
14453                                 NULL,
14454                                 test_command_generic);
14455
14456         /* LL Privacy
14457          * Setup: Enable Privacy, LL Privacy
14458          * Run: Pair device
14459          * Expect: The device is added to Accept List
14460          */
14461         test_bredrle50("LL Privacy - Pair 2 (Add to AL)",
14462                                 &ll_privacy_pair_2,
14463                                 NULL,
14464                                 test_ll_privacy_pair_2);
14465
14466         /* LL Privacy
14467          * Setup: Enable Privacy, LL Privacy
14468          * Run: Pair device, wait for New Key Event and unpair.
14469          * Expect: Receive Unpair event
14470          */
14471         test_bredrle50("LL Privacy - Unpair 1",
14472                                 &ll_privacy_unpair_1,
14473                                 NULL,
14474                                 test_ll_privacy_unpair);
14475
14476         /* LL Privacy
14477          * Setup: Enable Privacy, LL Privacy
14478          * Run: Pair device, disconnect, add device, add 2nd device, and
14479          *      remove the client, then unpair.
14480          * Expect: Expect the clinet is removed from the Accept List.
14481          */
14482         test_bredrle50_full("LL Privacy - Unpair 2 (Remove from AL)",
14483                                 &ll_privacy_unpair_2,
14484                                 NULL,
14485                                 test_ll_privacy_unpair_2, 5);
14486
14487         /* LL Privacy
14488          * Setup: Enable LL Privacy, add IRK of new device, Add Device
14489          * Run: Set Device Flags
14490          * Expect: Device Privacy Mode is set.
14491          */
14492         test_bredrle50("LL Privacy - Set Device Flag 1 (Device Privacy)",
14493                                 &ll_privacy_set_device_flag_1,
14494                                 setup_ll_privacy_add_device,
14495                                 test_command_generic);
14496
14497         return tester_run();
14498 }