Merge tag 'master-2014-07-31' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next

Conflicts:
	net/6lowpan/iphc.c

Minor conflicts in iphc.c were changes overlapping with some
style cleanups.

John W. Linville says:

====================
Please pull this last(?) batch of wireless change intended for the
3.17 stream...

For the NFC bits, Samuel says:

"This is a rather quiet one, we have:

- A new driver from ST Microelectronics for their NCI ST21NFCB,
  including device tree  support.

- p2p support for the ST21NFCA driver

- A few fixes an enhancements for the NFC digital laye"

For the Atheros bits, Kalle says:

"Michal and Janusz did some important RX aggregation fixes, basically we
were missing RX reordering altogether. The 10.1 firmware doesn't support
Ad-Hoc mode and Michal fixed ath10k so that it doesn't advertise Ad-Hoc
support with that firmware. Also he implemented a workaround for a KVM
issue."

For the Bluetooth bits, Gustavo and Johan say:

"To quote Gustavo from his previous request:

'Some last minute fixes for -next. We have a fix for a use after free in
RFCOMM, another fix to an issue with ADV_DIRECT_IND and one for ADV_IND with
auto-connection handling.  Last, we added support for reading the codec and
MWS setting for controllers that support these features.'

Additionally there are fixes to LE scanning, an update to conform to the 4.1
core specification as well as fixes for tracking the page scan state. All
of these fixes are important for 3.17."

And,

"We've got:

- 6lowpan fixes/cleanups
- A couple crash fixes, one for the Marvell HCI driver and another in LE SMP.
- Fix for an incorrect connected state check
- Fix for the bondable requirement during pairing (an issue which had
  crept in because of using "pairable" when in fact the actual meaning
  was "bondable" (these have different meanings in Bluetooth)"

Along with those are some late-breaking hardware support patches in
brcmfmac and b43 as well as a stray ath9k patch.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

6 files changed, 287 insertions, 47 deletions

diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index cfcb6055ced8..32b96f1aaf42 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -970,6 +970,62 @@ static int adv_channel_map_get(void *data, u64 *val)
 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
                         adv_channel_map_set, "%llu\n");
 
+static int adv_min_interval_set(void *data, u64 val)
+{
+        struct hci_dev *hdev = data;
+
+        if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
+                return -EINVAL;
+
+        hci_dev_lock(hdev);
+        hdev->le_adv_min_interval = val;
+        hci_dev_unlock(hdev);
+
+        return 0;
+}
+
+static int adv_min_interval_get(void *data, u64 *val)
+{
+        struct hci_dev *hdev = data;
+
+        hci_dev_lock(hdev);
+        *val = hdev->le_adv_min_interval;
+        hci_dev_unlock(hdev);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
+                        adv_min_interval_set, "%llu\n");
+
+static int adv_max_interval_set(void *data, u64 val)
+{
+        struct hci_dev *hdev = data;
+
+        if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
+                return -EINVAL;
+
+        hci_dev_lock(hdev);
+        hdev->le_adv_max_interval = val;
+        hci_dev_unlock(hdev);
+
+        return 0;
+}
+
+static int adv_max_interval_get(void *data, u64 *val)
+{
+        struct hci_dev *hdev = data;
+
+        hci_dev_lock(hdev);
+        *val = hdev->le_adv_max_interval;
+        hci_dev_unlock(hdev);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
+                        adv_max_interval_set, "%llu\n");
+
 static int device_list_show(struct seq_file *f, void *ptr)
 {
         struct hci_dev *hdev = f->private;
@@ -1567,7 +1623,7 @@ static void hci_set_le_support(struct hci_request *req)
 
         if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
                 cp.le = 0x01;
-                cp.simul = lmp_le_br_capable(hdev);
+                cp.simul = 0x00;
         }
 
         if (cp.le != lmp_host_le_capable(hdev))
@@ -1686,6 +1742,14 @@ static void hci_init4_req(struct hci_request *req, unsigned long opt)
         if (hdev->commands[22] & 0x04)
                 hci_set_event_mask_page_2(req);
 
+        /* Read local codec list if the HCI command is supported */
+        if (hdev->commands[29] & 0x20)
+                hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL);
+
+        /* Get MWS transport configuration if the HCI command is supported */
+        if (hdev->commands[30] & 0x08)
+                hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL);
+
         /* Check for Synchronization Train support */
         if (lmp_sync_train_capable(hdev))
                 hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL);
@@ -1825,6 +1889,10 @@ static int __hci_init(struct hci_dev *hdev)
                                     hdev, &supervision_timeout_fops);
                 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs,
                                     hdev, &adv_channel_map_fops);
+                debugfs_create_file("adv_min_interval", 0644, hdev->debugfs,
+                                    hdev, &adv_min_interval_fops);
+                debugfs_create_file("adv_max_interval", 0644, hdev->debugfs,
+                                    hdev, &adv_max_interval_fops);
                 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
                                     &device_list_fops);
                 debugfs_create_u16("discov_interleaved_timeout", 0644,
@@ -2453,14 +2521,14 @@ int hci_dev_open(__u16 dev)
         flush_workqueue(hdev->req_workqueue);
 
         /* For controllers not using the management interface and that
-         * are brought up using legacy ioctl, set the HCI_PAIRABLE bit
+         * are brought up using legacy ioctl, set the HCI_BONDABLE bit
          * so that pairing works for them. Once the management interface
          * is in use this bit will be cleared again and userspace has
          * to explicitly enable it.
          */
         if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) &&
             !test_bit(HCI_MGMT, &hdev->dev_flags))
-                set_bit(HCI_PAIRABLE, &hdev->dev_flags);
+                set_bit(HCI_BONDABLE, &hdev->dev_flags);
 
         err = hci_dev_do_open(hdev);
 
@@ -3639,6 +3707,7 @@ int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type,
                 list_add(&params->action, &hdev->pend_le_reports);
                 hci_update_background_scan(hdev);
                 break;
+        case HCI_AUTO_CONN_DIRECT:
         case HCI_AUTO_CONN_ALWAYS:
                 if (!is_connected(hdev, addr, addr_type)) {
                         list_add(&params->action, &hdev->pend_le_conns);
@@ -3914,6 +3983,8 @@ struct hci_dev *hci_alloc_dev(void)
         hdev->sniff_min_interval = 80;
 
         hdev->le_adv_channel_map = 0x07;
+        hdev->le_adv_min_interval = 0x0800;
+        hdev->le_adv_max_interval = 0x0800;
         hdev->le_scan_interval = 0x0060;
         hdev->le_scan_window = 0x0030;
         hdev->le_conn_min_interval = 0x0028;
@@ -5397,12 +5468,113 @@ void hci_req_add_le_scan_disable(struct hci_request *req)
         hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
 }
 
+static void add_to_white_list(struct hci_request *req,
+                              struct hci_conn_params *params)
+{
+        struct hci_cp_le_add_to_white_list cp;
+
+        cp.bdaddr_type = params->addr_type;
+        bacpy(&cp.bdaddr, &params->addr);
+
+        hci_req_add(req, HCI_OP_LE_ADD_TO_WHITE_LIST, sizeof(cp), &cp);
+}
+
+static u8 update_white_list(struct hci_request *req)
+{
+        struct hci_dev *hdev = req->hdev;
+        struct hci_conn_params *params;
+        struct bdaddr_list *b;
+        uint8_t white_list_entries = 0;
+
+        /* Go through the current white list programmed into the
+         * controller one by one and check if that address is still
+         * in the list of pending connections or list of devices to
+         * report. If not present in either list, then queue the
+         * command to remove it from the controller.
+         */
+        list_for_each_entry(b, &hdev->le_white_list, list) {
+                struct hci_cp_le_del_from_white_list cp;
+
+                if (hci_pend_le_action_lookup(&hdev->pend_le_conns,
+                                              &b->bdaddr, b->bdaddr_type) ||
+                    hci_pend_le_action_lookup(&hdev->pend_le_reports,
+                                              &b->bdaddr, b->bdaddr_type)) {
+                        white_list_entries++;
+                        continue;
+                }
+
+                cp.bdaddr_type = b->bdaddr_type;
+                bacpy(&cp.bdaddr, &b->bdaddr);
+
+                hci_req_add(req, HCI_OP_LE_DEL_FROM_WHITE_LIST,
+                            sizeof(cp), &cp);
+        }
+
+        /* Since all no longer valid white list entries have been
+         * removed, walk through the list of pending connections
+         * and ensure that any new device gets programmed into
+         * the controller.
+         *
+         * If the list of the devices is larger than the list of
+         * available white list entries in the controller, then
+         * just abort and return filer policy value to not use the
+         * white list.
+         */
+        list_for_each_entry(params, &hdev->pend_le_conns, action) {
+                if (hci_bdaddr_list_lookup(&hdev->le_white_list,
+                                           &params->addr, params->addr_type))
+                        continue;
+
+                if (white_list_entries >= hdev->le_white_list_size) {
+                        /* Select filter policy to accept all advertising */
+                        return 0x00;
+                }
+
+                if (hci_find_irk_by_addr(hdev, &params->addr,
+                                         params->addr_type)) {
+                        /* White list can not be used with RPAs */
+                        return 0x00;
+                }
+
+                white_list_entries++;
+                add_to_white_list(req, params);
+        }
+
+        /* After adding all new pending connections, walk through
+         * the list of pending reports and also add these to the
+         * white list if there is still space.
+         */
+        list_for_each_entry(params, &hdev->pend_le_reports, action) {
+                if (hci_bdaddr_list_lookup(&hdev->le_white_list,
+                                           &params->addr, params->addr_type))
+                        continue;
+
+                if (white_list_entries >= hdev->le_white_list_size) {
+                        /* Select filter policy to accept all advertising */
+                        return 0x00;
+                }
+
+                if (hci_find_irk_by_addr(hdev, &params->addr,
+                                         params->addr_type)) {
+                        /* White list can not be used with RPAs */
+                        return 0x00;
+                }
+
+                white_list_entries++;
+                add_to_white_list(req, params);
+        }
+
+        /* Select filter policy to use white list */
+        return 0x01;
+}
+
 void hci_req_add_le_passive_scan(struct hci_request *req)
 {
         struct hci_cp_le_set_scan_param param_cp;
         struct hci_cp_le_set_scan_enable enable_cp;
         struct hci_dev *hdev = req->hdev;
         u8 own_addr_type;
+        u8 filter_policy;
 
         /* Set require_privacy to false since no SCAN_REQ are send
          * during passive scanning. Not using an unresolvable address
@@ -5413,11 +5585,18 @@ void hci_req_add_le_passive_scan(struct hci_request *req)
         if (hci_update_random_address(req, false, &own_addr_type))
                 return;
 
+        /* Adding or removing entries from the white list must
+         * happen before enabling scanning. The controller does
+         * not allow white list modification while scanning.
+         */
+        filter_policy = update_white_list(req);
+
         memset(&param_cp, 0, sizeof(param_cp));
         param_cp.type = LE_SCAN_PASSIVE;
         param_cp.interval = cpu_to_le16(hdev->le_scan_interval);
         param_cp.window = cpu_to_le16(hdev->le_scan_window);
         param_cp.own_address_type = own_addr_type;
+        param_cp.filter_policy = filter_policy;
         hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp),
                     &param_cp);
 
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 4c41774aa556..be35598984d9 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -317,7 +317,7 @@ static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
         if (param & SCAN_PAGE)
                 set_bit(HCI_PSCAN, &hdev->flags);
         else
-                clear_bit(HCI_ISCAN, &hdev->flags);
+                clear_bit(HCI_PSCAN, &hdev->flags);
 
 done:
         hci_dev_unlock(hdev);
@@ -2259,6 +2259,7 @@ static void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
                                 break;
                         /* Fall through */
 
+                case HCI_AUTO_CONN_DIRECT:
                 case HCI_AUTO_CONN_ALWAYS:
                         list_del_init(&params->action);
                         list_add(&params->action, &hdev->pend_le_conns);
@@ -3118,7 +3119,7 @@ static void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
                 hci_conn_drop(conn);
         }
 
-        if (!test_bit(HCI_PAIRABLE, &hdev->dev_flags) &&
+        if (!test_bit(HCI_BONDABLE, &hdev->dev_flags) &&
             !test_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags)) {
                 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
                              sizeof(ev->bdaddr), &ev->bdaddr);
@@ -3651,7 +3652,7 @@ static void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
         /* Allow pairing if we're pairable, the initiators of the
          * pairing or if the remote is not requesting bonding.
          */
-        if (test_bit(HCI_PAIRABLE, &hdev->dev_flags) ||
+        if (test_bit(HCI_BONDABLE, &hdev->dev_flags) ||
             test_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags) ||
             (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
                 struct hci_cp_io_capability_reply cp;
@@ -3670,13 +3671,18 @@ static void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
                         if (conn->io_capability != HCI_IO_NO_INPUT_OUTPUT &&
                             conn->auth_type != HCI_AT_NO_BONDING)
                                 conn->auth_type |= 0x01;
-
-                        cp.authentication = conn->auth_type;
                 } else {
                         conn->auth_type = hci_get_auth_req(conn);
-                        cp.authentication = conn->auth_type;
                 }
 
+                /* If we're not bondable, force one of the non-bondable
+                 * authentication requirement values.
+                 */
+                if (!test_bit(HCI_BONDABLE, &hdev->dev_flags))
+                        conn->auth_type &= HCI_AT_NO_BONDING_MITM;
+
+                cp.authentication = conn->auth_type;
+
                 if (hci_find_remote_oob_data(hdev, &conn->dst) &&
                     (conn->out || test_bit(HCI_CONN_REMOTE_OOB, &conn->flags)))
                         cp.oob_data = 0x01;
@@ -4251,6 +4257,7 @@ static void check_pending_le_conn(struct hci_dev *hdev, bdaddr_t *addr,
                                   u8 addr_type, u8 adv_type)
 {
         struct hci_conn *conn;
+        struct hci_conn_params *params;
 
         /* If the event is not connectable don't proceed further */
         if (adv_type != LE_ADV_IND && adv_type != LE_ADV_DIRECT_IND)
@@ -4266,18 +4273,35 @@ static void check_pending_le_conn(struct hci_dev *hdev, bdaddr_t *addr,
         if (hdev->conn_hash.le_num_slave > 0)
                 return;
 
-        /* If we're connectable, always connect any ADV_DIRECT_IND event */
-        if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags) &&
-            adv_type == LE_ADV_DIRECT_IND)
-                goto connect;
-
         /* If we're not connectable only connect devices that we have in
          * our pend_le_conns list.
          */
-        if (!hci_pend_le_action_lookup(&hdev->pend_le_conns, addr, addr_type))
+        params = hci_pend_le_action_lookup(&hdev->pend_le_conns,
+                                           addr, addr_type);
+        if (!params)
+                return;
+
+        switch (params->auto_connect) {
+        case HCI_AUTO_CONN_DIRECT:
+                /* Only devices advertising with ADV_DIRECT_IND are
+                 * triggering a connection attempt. This is allowing
+                 * incoming connections from slave devices.
+                 */
+                if (adv_type != LE_ADV_DIRECT_IND)
+                        return;
+                break;
+        case HCI_AUTO_CONN_ALWAYS:
+                /* Devices advertising with ADV_IND or ADV_DIRECT_IND
+                 * are triggering a connection attempt. This means
+                 * that incoming connectioms from slave device are
+                 * accepted and also outgoing connections to slave
+                 * devices are established when found.
+                 */
+                break;
+        default:
                 return;
+        }
 
-connect:
         conn = hci_connect_le(hdev, addr, addr_type, BT_SECURITY_LOW,
                               HCI_LE_AUTOCONN_TIMEOUT, HCI_ROLE_MASTER);
         if (!IS_ERR(conn))
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 8181ea4bc2f2..6c7ecf116e74 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -154,7 +154,7 @@ static int hidp_input_event(struct input_dev *dev, unsigned int type,
                   (!!test_bit(LED_COMPOSE, dev->led) << 3) |
                   (!!test_bit(LED_SCROLLL, dev->led) << 2) |
                   (!!test_bit(LED_CAPSL,   dev->led) << 1) |
-                  (!!test_bit(LED_NUML,    dev->led));
+                  (!!test_bit(LED_NUML,    dev->led) << 0);
 
         if (session->leds == newleds)
                 return 0;
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index 190668367e42..b8554d429d88 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -44,7 +44,7 @@ static const u16 mgmt_commands[] = {
         MGMT_OP_SET_DISCOVERABLE,
         MGMT_OP_SET_CONNECTABLE,
         MGMT_OP_SET_FAST_CONNECTABLE,
-        MGMT_OP_SET_PAIRABLE,
+        MGMT_OP_SET_BONDABLE,
         MGMT_OP_SET_LINK_SECURITY,
         MGMT_OP_SET_SSP,
         MGMT_OP_SET_HS,
@@ -553,7 +553,7 @@ static u32 get_supported_settings(struct hci_dev *hdev)
         u32 settings = 0;
 
         settings |= MGMT_SETTING_POWERED;
-        settings |= MGMT_SETTING_PAIRABLE;
+        settings |= MGMT_SETTING_BONDABLE;
         settings |= MGMT_SETTING_DEBUG_KEYS;
         settings |= MGMT_SETTING_CONNECTABLE;
         settings |= MGMT_SETTING_DISCOVERABLE;
@@ -603,8 +603,8 @@ static u32 get_current_settings(struct hci_dev *hdev)
         if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
                 settings |= MGMT_SETTING_DISCOVERABLE;
 
-        if (test_bit(HCI_PAIRABLE, &hdev->dev_flags))
-                settings |= MGMT_SETTING_PAIRABLE;
+        if (test_bit(HCI_BONDABLE, &hdev->dev_flags))
+                settings |= MGMT_SETTING_BONDABLE;
 
         if (test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
                 settings |= MGMT_SETTING_BREDR;
@@ -1086,8 +1086,8 @@ static void enable_advertising(struct hci_request *req)
                 return;
 
         memset(&cp, 0, sizeof(cp));
-        cp.min_interval = cpu_to_le16(0x0800);
-        cp.max_interval = cpu_to_le16(0x0800);
+        cp.min_interval = cpu_to_le16(hdev->le_adv_min_interval);
+        cp.max_interval = cpu_to_le16(hdev->le_adv_max_interval);
         cp.type = connectable ? LE_ADV_IND : LE_ADV_NONCONN_IND;
         cp.own_address_type = own_addr_type;
         cp.channel_map = hdev->le_adv_channel_map;
@@ -1152,7 +1152,7 @@ static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
          * for mgmt we require user-space to explicitly enable
          * it
          */
-        clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
+        clear_bit(HCI_BONDABLE, &hdev->dev_flags);
 }
 
 static int read_controller_info(struct sock *sk, struct hci_dev *hdev,
@@ -1881,7 +1881,18 @@ static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
                 if (cp->val) {
                         scan = SCAN_PAGE;
                 } else {
-                        scan = 0;
+                        /* If we don't have any whitelist entries just
+                         * disable all scanning. If there are entries
+                         * and we had both page and inquiry scanning
+                         * enabled then fall back to only page scanning.
+                         * Otherwise no changes are needed.
+                         */
+                        if (list_empty(&hdev->whitelist))
+                                scan = SCAN_DISABLED;
+                        else if (test_bit(HCI_ISCAN, &hdev->flags))
+                                scan = SCAN_PAGE;
+                        else
+                                goto no_scan_update;
 
                         if (test_bit(HCI_ISCAN, &hdev->flags) &&
                             hdev->discov_timeout > 0)
@@ -1891,6 +1902,7 @@ static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
                 hci_req_add(&req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
         }
 
+no_scan_update:
         /* If we're going from non-connectable to connectable or
          * vice-versa when fast connectable is enabled ensure that fast
          * connectable gets disabled. write_fast_connectable won't do
@@ -1918,7 +1930,7 @@ failed:
         return err;
 }
 
-static int set_pairable(struct sock *sk, struct hci_dev *hdev, void *data,
+static int set_bondable(struct sock *sk, struct hci_dev *hdev, void *data,
                         u16 len)
 {
         struct mgmt_mode *cp = data;
@@ -1928,17 +1940,17 @@ static int set_pairable(struct sock *sk, struct hci_dev *hdev, void *data,
         BT_DBG("request for %s", hdev->name);
 
         if (cp->val != 0x00 && cp->val != 0x01)
-                return cmd_status(sk, hdev->id, MGMT_OP_SET_PAIRABLE,
+                return cmd_status(sk, hdev->id, MGMT_OP_SET_BONDABLE,
                                   MGMT_STATUS_INVALID_PARAMS);
 
         hci_dev_lock(hdev);
 
         if (cp->val)
-                changed = !test_and_set_bit(HCI_PAIRABLE, &hdev->dev_flags);
+                changed = !test_and_set_bit(HCI_BONDABLE, &hdev->dev_flags);
         else
-                changed = test_and_clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
+                changed = test_and_clear_bit(HCI_BONDABLE, &hdev->dev_flags);
 
-        err = send_settings_rsp(sk, MGMT_OP_SET_PAIRABLE, hdev);
+        err = send_settings_rsp(sk, MGMT_OP_SET_BONDABLE, hdev);
         if (err < 0)
                 goto unlock;
 
@@ -2264,7 +2276,7 @@ static int set_le(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
 
         if (val) {
                 hci_cp.le = val;
-                hci_cp.simul = lmp_le_br_capable(hdev);
+                hci_cp.simul = 0x00;
         } else {
                 if (test_bit(HCI_LE_ADV, &hdev->dev_flags))
                         disable_advertising(&req);
@@ -3201,7 +3213,7 @@ static int pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
         conn->io_capability = cp->io_cap;
         cmd->user_data = conn;
 
-        if (conn->state == BT_CONNECTED &&
+        if ((conn->state == BT_CONNECTED || conn->state == BT_CONFIG) &&
             hci_conn_security(conn, sec_level, auth_type, true))
                 pairing_complete(cmd, 0);
 
@@ -5271,7 +5283,7 @@ static int add_device(struct sock *sk, struct hci_dev *hdev,
                                     MGMT_STATUS_INVALID_PARAMS,
                                     &cp->addr, sizeof(cp->addr));
 
-        if (cp->action != 0x00 && cp->action != 0x01)
+        if (cp->action != 0x00 && cp->action != 0x01 && cp->action != 0x02)
                 return cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
                                     MGMT_STATUS_INVALID_PARAMS,
                                     &cp->addr, sizeof(cp->addr));
@@ -5281,7 +5293,7 @@ static int add_device(struct sock *sk, struct hci_dev *hdev,
         if (cp->addr.type == BDADDR_BREDR) {
                 bool update_scan;
 
-                /* Only "connect" action supported for now */
+                /* Only incoming connections action is supported for now */
                 if (cp->action != 0x01) {
                         err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
                                            MGMT_STATUS_INVALID_PARAMS,
@@ -5307,8 +5319,10 @@ static int add_device(struct sock *sk, struct hci_dev *hdev,
         else
                 addr_type = ADDR_LE_DEV_RANDOM;
 
-        if (cp->action)
+        if (cp->action == 0x02)
                 auto_conn = HCI_AUTO_CONN_ALWAYS;
+        else if (cp->action == 0x01)
+                auto_conn = HCI_AUTO_CONN_DIRECT;
         else
                 auto_conn = HCI_AUTO_CONN_REPORT;
 
@@ -5665,7 +5679,7 @@ static const struct mgmt_handler {
         { set_discoverable,       false, MGMT_SET_DISCOVERABLE_SIZE },
         { set_connectable,        false, MGMT_SETTING_SIZE },
         { set_fast_connectable,   false, MGMT_SETTING_SIZE },
-        { set_pairable,           false, MGMT_SETTING_SIZE },
+        { set_bondable,           false, MGMT_SETTING_SIZE },
         { set_link_security,      false, MGMT_SETTING_SIZE },
         { set_ssp,                false, MGMT_SETTING_SIZE },
         { set_hs,                 false, MGMT_SETTING_SIZE },
@@ -5870,6 +5884,7 @@ static void restart_le_actions(struct hci_dev *hdev)
                 list_del_init(&p->action);
 
                 switch (p->auto_connect) {
+                case HCI_AUTO_CONN_DIRECT:
                 case HCI_AUTO_CONN_ALWAYS:
                         list_add(&p->action, &hdev->pend_le_conns);
                         break;
@@ -5922,8 +5937,8 @@ static int powered_update_hci(struct hci_dev *hdev)
             lmp_bredr_capable(hdev)) {
                 struct hci_cp_write_le_host_supported cp;
 
-                cp.le = 1;
-                cp.simul = lmp_le_br_capable(hdev);
+                cp.le = 0x01;
+                cp.simul = 0x00;
 
                 /* Check first if we already have the right
                  * host state (host features set)
diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index a0690a84f3e9..af73bc3acb40 100644
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -1910,10 +1910,13 @@ static struct rfcomm_session *rfcomm_process_rx(struct rfcomm_session *s)
         /* Get data directly from socket receive queue without copying it. */
         while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
                 skb_orphan(skb);
-                if (!skb_linearize(skb))
+                if (!skb_linearize(skb)) {
                         s = rfcomm_recv_frame(s, skb);
-                else
+                        if (!s)
+                                break;
+                } else {
                         kfree_skb(skb);
+                }
         }
 
         if (s && (sk->sk_state == BT_CLOSED))
diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index e49c83d8b957..fd3294300803 100644
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -307,7 +307,7 @@ static void build_pairing_cmd(struct l2cap_conn *conn,
         struct hci_dev *hdev = hcon->hdev;
         u8 local_dist = 0, remote_dist = 0;
 
-        if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
+        if (test_bit(HCI_BONDABLE, &conn->hcon->hdev->dev_flags)) {
                 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
                 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
                 authreq |= SMP_AUTH_BONDING;
@@ -579,13 +579,16 @@ static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
         struct smp_chan *smp;
 
         smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
-        if (!smp)
+        if (!smp) {
+                clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags);
                 return NULL;
+        }
 
         smp->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
         if (IS_ERR(smp->tfm_aes)) {
                 BT_ERR("Unable to create ECB crypto context");
                 kfree(smp);
+                clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags);
                 return NULL;
         }
 
@@ -701,7 +704,7 @@ static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
         if (!smp)
                 return SMP_UNSPECIFIED;
 
-        if (!test_bit(HCI_PAIRABLE, &hdev->dev_flags) &&
+        if (!test_bit(HCI_BONDABLE, &hdev->dev_flags) &&
             (req->auth_req & SMP_AUTH_BONDING))
                 return SMP_PAIRING_NOTSUPP;
 
@@ -923,14 +926,14 @@ static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
         if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
                 return 0;
 
-        if (!test_bit(HCI_PAIRABLE, &hcon->hdev->dev_flags) &&
-            (rp->auth_req & SMP_AUTH_BONDING))
-                return SMP_PAIRING_NOTSUPP;
-
         smp = smp_chan_create(conn);
         if (!smp)
                 return SMP_UNSPECIFIED;
 
+        if (!test_bit(HCI_BONDABLE, &hcon->hdev->dev_flags) &&
+            (rp->auth_req & SMP_AUTH_BONDING))
+                return SMP_PAIRING_NOTSUPP;
+
         skb_pull(skb, sizeof(*rp));
 
         memset(&cp, 0, sizeof(cp));
@@ -1291,6 +1294,22 @@ static void smp_notify_keys(struct l2cap_conn *conn)
                 bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
                 hcon->dst_type = smp->remote_irk->addr_type;
                 l2cap_conn_update_id_addr(hcon);
+
+                /* When receiving an indentity resolving key for
+                 * a remote device that does not use a resolvable
+                 * private address, just remove the key so that
+                 * it is possible to use the controller white
+                 * list for scanning.
+                 *
+                 * Userspace will have been told to not store
+                 * this key at this point. So it is safe to
+                 * just remove it.
+                 */
+                if (!bacmp(&smp->remote_irk->rpa, BDADDR_ANY)) {
+                        list_del(&smp->remote_irk->list);
+                        kfree(smp->remote_irk);
+                        smp->remote_irk = NULL;
+                }
         }
 
         /* The LTKs and CSRKs should be persistent only if both sides