if (event->length > 3 && event->data[3])
                                priv->btmrvl_dev.dev_type = HCI_AMP;
                        else
-                               priv->btmrvl_dev.dev_type = HCI_BREDR;
+                               priv->btmrvl_dev.dev_type = HCI_PRIMARY;
 
                        BT_DBG("dev_type: %d", priv->btmrvl_dev.dev_type);
                } else if (priv->btmrvl_dev.sendcmdflag &&
 
        if (id->class == SDIO_CLASS_BT_AMP)
                hdev->dev_type = HCI_AMP;
        else
-               hdev->dev_type = HCI_BREDR;
+               hdev->dev_type = HCI_PRIMARY;
 
        data->hdev = hdev;
 
 
        if (id->driver_info & BTUSB_AMP)
                hdev->dev_type = HCI_AMP;
        else
-               hdev->dev_type = HCI_BREDR;
+               hdev->dev_type = HCI_PRIMARY;
 
        data->hdev = hdev;
 
 
        if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags))
                hdev->dev_type = HCI_AMP;
        else
-               hdev->dev_type = HCI_BREDR;
+               hdev->dev_type = HCI_PRIMARY;
 
        if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
                return 0;
 
        if (data->hdev)
                return -EBADFD;
 
-       /* bits 0-1 are dev_type (BR/EDR or AMP) */
+       /* bits 0-1 are dev_type (Primary or AMP) */
        dev_type = opcode & 0x03;
 
-       if (dev_type != HCI_BREDR && dev_type != HCI_AMP)
+       if (dev_type != HCI_PRIMARY && dev_type != HCI_AMP)
                return -EINVAL;
 
        /* bits 2-5 are reserved (must be zero) */
        struct vhci_data *data = container_of(work, struct vhci_data,
                                              open_timeout.work);
 
-       vhci_create_device(data, amp ? HCI_AMP : HCI_BREDR);
+       vhci_create_device(data, amp ? HCI_AMP : HCI_PRIMARY);
 }
 
 static int vhci_open(struct inode *inode, struct file *file)
 
 #define HCI_I2C                8
 
 /* HCI controller types */
-#define HCI_BREDR      0x00
+#define HCI_PRIMARY    0x00
 #define HCI_AMP                0x01
 
 /* First BR/EDR Controller shall have ID = 0 */
 
        list_for_each_entry(d, &hci_dev_list, list) {
                if (!test_bit(HCI_UP, &d->flags) ||
                    hci_dev_test_flag(d, HCI_USER_CHANNEL) ||
-                   d->dev_type != HCI_BREDR)
+                   d->dev_type != HCI_PRIMARY)
                        continue;
 
                /* Simple routing:
 
                hci_reset_req(req, 0);
 
        switch (hdev->dev_type) {
-       case HCI_BREDR:
+       case HCI_PRIMARY:
                bredr_init(req);
                break;
-
        case HCI_AMP:
                amp_init1(req);
                break;
-
        default:
                BT_ERR("Unknown device type %d", hdev->dev_type);
                break;
        if (err < 0)
                return err;
 
-       /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode
+       /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode
         * BR/EDR/LE type controllers. AMP controllers only need the
         * first two stages of init.
         */
-       if (hdev->dev_type != HCI_BREDR)
+       if (hdev->dev_type != HCI_PRIMARY)
                return 0;
 
        err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL);
                goto done;
        }
 
-       if (hdev->dev_type != HCI_BREDR) {
+       if (hdev->dev_type != HCI_PRIMARY) {
                err = -EOPNOTSUPP;
                goto done;
        }
                 * since AMP controllers do not have an address.
                 */
                if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) &&
-                   hdev->dev_type == HCI_BREDR &&
+                   hdev->dev_type == HCI_PRIMARY &&
                    !bacmp(&hdev->bdaddr, BDADDR_ANY) &&
                    !bacmp(&hdev->static_addr, BDADDR_ANY)) {
                        ret = -EADDRNOTAVAIL;
                    !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) &&
                    !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) &&
                    hci_dev_test_flag(hdev, HCI_MGMT) &&
-                   hdev->dev_type == HCI_BREDR) {
+                   hdev->dev_type == HCI_PRIMARY) {
                        ret = __hci_req_hci_power_on(hdev);
                        mgmt_power_on(hdev, ret);
                }
 
        auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF);
 
-       if (!auto_off && hdev->dev_type == HCI_BREDR &&
+       if (!auto_off && hdev->dev_type == HCI_PRIMARY &&
            hci_dev_test_flag(hdev, HCI_MGMT))
                __mgmt_power_off(hdev);
 
                goto done;
        }
 
-       if (hdev->dev_type != HCI_BREDR) {
+       if (hdev->dev_type != HCI_PRIMARY) {
                err = -EOPNOTSUPP;
                goto done;
        }
         */
        if (hci_dev_test_flag(hdev, HCI_RFKILLED) ||
            hci_dev_test_flag(hdev, HCI_UNCONFIGURED) ||
-           (hdev->dev_type == HCI_BREDR &&
+           (hdev->dev_type == HCI_PRIMARY &&
             !bacmp(&hdev->bdaddr, BDADDR_ANY) &&
             !bacmp(&hdev->static_addr, BDADDR_ANY))) {
                hci_dev_clear_flag(hdev, HCI_AUTO_OFF);
         * so the index can be used as the AMP controller ID.
         */
        switch (hdev->dev_type) {
-       case HCI_BREDR:
+       case HCI_PRIMARY:
                id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL);
                break;
        case HCI_AMP:
        hci_dev_set_flag(hdev, HCI_SETUP);
        hci_dev_set_flag(hdev, HCI_AUTO_OFF);
 
-       if (hdev->dev_type == HCI_BREDR) {
+       if (hdev->dev_type == HCI_PRIMARY) {
                /* Assume BR/EDR support until proven otherwise (such as
                 * through reading supported features during init.
                 */
        hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT;
 
        switch (hdev->dev_type) {
-       case HCI_BREDR:
+       case HCI_PRIMARY:
                hci_add_acl_hdr(skb, conn->handle, flags);
                break;
        case HCI_AMP:
        BT_DBG("%s", hdev->name);
 
        /* No ACL link over BR/EDR controller */
-       if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR)
+       if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY)
                return;
 
        /* No AMP link over AMP controller */
 
        struct hci_chan *chan;
 
        switch (hdev->dev_type) {
-       case HCI_BREDR:
+       case HCI_PRIMARY:
                return hci_conn_hash_lookup_handle(hdev, handle);
        case HCI_AMP:
                chan = hci_chan_lookup_handle(hdev, handle);
 
        if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED))
                return -EOPNOTSUPP;
 
-       if (hdev->dev_type != HCI_BREDR)
+       if (hdev->dev_type != HCI_PRIMARY)
                return -EOPNOTSUPP;
 
        switch (cmd) {
 
        int len;
 
        /* For AMP controller do not create l2cap conn */
-       if (!conn && hcon->hdev->dev_type != HCI_BREDR)
+       if (!conn && hcon->hdev->dev_type != HCI_PRIMARY)
                goto drop;
 
        if (!conn)
 
 
        count = 0;
        list_for_each_entry(d, &hci_dev_list, list) {
-               if (d->dev_type == HCI_BREDR &&
+               if (d->dev_type == HCI_PRIMARY &&
                    !hci_dev_test_flag(d, HCI_UNCONFIGURED))
                        count++;
        }
                if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks))
                        continue;
 
-               if (d->dev_type == HCI_BREDR &&
+               if (d->dev_type == HCI_PRIMARY &&
                    !hci_dev_test_flag(d, HCI_UNCONFIGURED)) {
                        rp->index[count++] = cpu_to_le16(d->id);
                        BT_DBG("Added hci%u", d->id);
 
        count = 0;
        list_for_each_entry(d, &hci_dev_list, list) {
-               if (d->dev_type == HCI_BREDR &&
+               if (d->dev_type == HCI_PRIMARY &&
                    hci_dev_test_flag(d, HCI_UNCONFIGURED))
                        count++;
        }
                if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks))
                        continue;
 
-               if (d->dev_type == HCI_BREDR &&
+               if (d->dev_type == HCI_PRIMARY &&
                    hci_dev_test_flag(d, HCI_UNCONFIGURED)) {
                        rp->index[count++] = cpu_to_le16(d->id);
                        BT_DBG("Added hci%u", d->id);
 
        count = 0;
        list_for_each_entry(d, &hci_dev_list, list) {
-               if (d->dev_type == HCI_BREDR || d->dev_type == HCI_AMP)
+               if (d->dev_type == HCI_PRIMARY || d->dev_type == HCI_AMP)
                        count++;
        }
 
                if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks))
                        continue;
 
-               if (d->dev_type == HCI_BREDR) {
+               if (d->dev_type == HCI_PRIMARY) {
                        if (hci_dev_test_flag(d, HCI_UNCONFIGURED))
                                rp->entry[count].type = 0x01;
                        else
                return;
 
        switch (hdev->dev_type) {
-       case HCI_BREDR:
+       case HCI_PRIMARY:
                if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) {
                        mgmt_index_event(MGMT_EV_UNCONF_INDEX_ADDED, hdev,
                                         NULL, 0, HCI_MGMT_UNCONF_INDEX_EVENTS);
                return;
 
        switch (hdev->dev_type) {
-       case HCI_BREDR:
+       case HCI_PRIMARY:
                mgmt_pending_foreach(0, hdev, cmd_complete_rsp, &status);
 
                if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) {