]> git.ipfire.org Git - thirdparty/kernel/linux.git/commitdiff
Bluetooth: hci_dev: replace 'quirks' integer by 'quirk_flags' bitmap
authorChristian Eggers <ceggers@arri.de>
Mon, 14 Jul 2025 20:27:45 +0000 (22:27 +0200)
committerLuiz Augusto von Dentz <luiz.von.dentz@intel.com>
Wed, 16 Jul 2025 19:37:53 +0000 (15:37 -0400)
The 'quirks' member already ran out of bits on some platforms some time
ago. Replace the integer member by a bitmap in order to have enough bits
in future. Replace raw bit operations by accessor macros.

Fixes: ff26b2dd6568 ("Bluetooth: Add quirk for broken READ_VOICE_SETTING")
Fixes: 127881334eaa ("Bluetooth: Add quirk for broken READ_PAGE_SCAN_TYPE")
Suggested-by: Pauli Virtanen <pav@iki.fi>
Tested-by: Ivan Pravdin <ipravdin.official@gmail.com>
Signed-off-by: Kiran K <kiran.k@intel.com>
Signed-off-by: Christian Eggers <ceggers@arri.de>
Signed-off-by: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
32 files changed:
drivers/bluetooth/bfusb.c
drivers/bluetooth/bpa10x.c
drivers/bluetooth/btbcm.c
drivers/bluetooth/btintel.c
drivers/bluetooth/btintel_pcie.c
drivers/bluetooth/btmtksdio.c
drivers/bluetooth/btmtkuart.c
drivers/bluetooth/btnxpuart.c
drivers/bluetooth/btqca.c
drivers/bluetooth/btqcomsmd.c
drivers/bluetooth/btrtl.c
drivers/bluetooth/btsdio.c
drivers/bluetooth/btusb.c
drivers/bluetooth/hci_aml.c
drivers/bluetooth/hci_bcm.c
drivers/bluetooth/hci_bcm4377.c
drivers/bluetooth/hci_intel.c
drivers/bluetooth/hci_ldisc.c
drivers/bluetooth/hci_ll.c
drivers/bluetooth/hci_nokia.c
drivers/bluetooth/hci_qca.c
drivers/bluetooth/hci_serdev.c
drivers/bluetooth/hci_vhci.c
drivers/bluetooth/virtio_bt.c
include/net/bluetooth/hci.h
include/net/bluetooth/hci_core.h
net/bluetooth/hci_core.c
net/bluetooth/hci_debugfs.c
net/bluetooth/hci_event.c
net/bluetooth/hci_sync.c
net/bluetooth/mgmt.c
net/bluetooth/msft.c

index 0d6ad50da0466e1d0c2ccbeb70bf18bddcda2667..8df310983bf6b3625087f67bd453a14597438efa 100644 (file)
@@ -670,7 +670,7 @@ static int bfusb_probe(struct usb_interface *intf, const struct usb_device_id *i
        hdev->flush = bfusb_flush;
        hdev->send  = bfusb_send_frame;
 
-       set_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LOCAL_COMMANDS);
 
        if (hci_register_dev(hdev) < 0) {
                BT_ERR("Can't register HCI device");
index 1fa58c059cbf5c6e115ccf5c3970b1165afe89b2..8b43dfc755de19242499359e0b510ae5a036d6a4 100644 (file)
@@ -398,7 +398,7 @@ static int bpa10x_probe(struct usb_interface *intf,
        hdev->send     = bpa10x_send_frame;
        hdev->set_diag = bpa10x_set_diag;
 
-       set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
 
        err = hci_register_dev(hdev);
        if (err < 0) {
index 0a60660fc8ce80d6d360ae5e8600f5c3191778ec..3a3a56ddbb06d05f4b7572d0c90ff90fa60ced6f 100644 (file)
@@ -135,7 +135,7 @@ int btbcm_check_bdaddr(struct hci_dev *hdev)
                if (btbcm_set_bdaddr_from_efi(hdev) != 0) {
                        bt_dev_info(hdev, "BCM: Using default device address (%pMR)",
                                    &bda->bdaddr);
-                       set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
                }
        }
 
@@ -467,7 +467,7 @@ static int btbcm_print_controller_features(struct hci_dev *hdev)
 
        /* Read DMI and disable broken Read LE Min/Max Tx Power */
        if (dmi_first_match(disable_broken_read_transmit_power))
-               set_bit(HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER);
 
        return 0;
 }
@@ -706,7 +706,7 @@ int btbcm_finalize(struct hci_dev *hdev, bool *fw_load_done, bool use_autobaud_m
 
        btbcm_check_bdaddr(hdev);
 
-       set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
 
        return 0;
 }
@@ -769,7 +769,7 @@ int btbcm_setup_apple(struct hci_dev *hdev)
                kfree_skb(skb);
        }
 
-       set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
 
        return 0;
 }
index 06575a0b9aeebdbc7ab901904ef81a51c16f6b36..06016ac3965c39c471a08d5ff0031f6bde44cc67 100644 (file)
@@ -88,7 +88,7 @@ int btintel_check_bdaddr(struct hci_dev *hdev)
        if (!bacmp(&bda->bdaddr, BDADDR_INTEL)) {
                bt_dev_err(hdev, "Found Intel default device address (%pMR)",
                           &bda->bdaddr);
-               set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
        }
 
        kfree_skb(skb);
@@ -2027,7 +2027,7 @@ static int btintel_download_fw(struct hci_dev *hdev,
         */
        if (!bacmp(&params->otp_bdaddr, BDADDR_ANY)) {
                bt_dev_info(hdev, "No device address configured");
-               set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
        }
 
 download:
@@ -2295,7 +2295,7 @@ static int btintel_prepare_fw_download_tlv(struct hci_dev *hdev,
                 */
                if (!bacmp(&ver->otp_bd_addr, BDADDR_ANY)) {
                        bt_dev_info(hdev, "No device address configured");
-                       set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
                }
        }
 
@@ -3435,9 +3435,9 @@ static int btintel_setup_combined(struct hci_dev *hdev)
        }
 
        /* Apply the common HCI quirks for Intel device */
-       set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
-       set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
-       set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
+       hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
+       hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_DIAG);
 
        /* Set up the quality report callback for Intel devices */
        hdev->set_quality_report = btintel_set_quality_report;
@@ -3475,8 +3475,8 @@ static int btintel_setup_combined(struct hci_dev *hdev)
                         */
                        if (!btintel_test_flag(hdev,
                                               INTEL_ROM_LEGACY_NO_WBS_SUPPORT))
-                               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED,
-                                       &hdev->quirks);
+                               hci_set_quirk(hdev,
+                                             HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                        err = btintel_legacy_rom_setup(hdev, &ver);
                        break;
@@ -3491,11 +3491,11 @@ static int btintel_setup_combined(struct hci_dev *hdev)
                         *
                         * All Legacy bootloader devices support WBS
                         */
-                       set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED,
-                               &hdev->quirks);
+                       hci_set_quirk(hdev,
+                                     HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                        /* These variants don't seem to support LE Coded PHY */
-                       set_bit(HCI_QUIRK_BROKEN_LE_CODED, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LE_CODED);
 
                        /* Setup MSFT Extension support */
                        btintel_set_msft_opcode(hdev, ver.hw_variant);
@@ -3571,10 +3571,10 @@ static int btintel_setup_combined(struct hci_dev *hdev)
                 *
                 * All Legacy bootloader devices support WBS
                 */
-               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                /* These variants don't seem to support LE Coded PHY */
-               set_bit(HCI_QUIRK_BROKEN_LE_CODED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LE_CODED);
 
                /* Setup MSFT Extension support */
                btintel_set_msft_opcode(hdev, ver.hw_variant);
@@ -3600,7 +3600,7 @@ static int btintel_setup_combined(struct hci_dev *hdev)
                 *
                 * All TLV based devices support WBS
                 */
-               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                /* Setup MSFT Extension support */
                btintel_set_msft_opcode(hdev,
index e1c688dd2d45a4e3b78e232868bdb75794c6abca..f4e3fb54fe766d208a74bd3adfe6c04d113e7913 100644 (file)
@@ -2081,9 +2081,9 @@ static int btintel_pcie_setup_internal(struct hci_dev *hdev)
        }
 
        /* Apply the common HCI quirks for Intel device */
-       set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
-       set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
-       set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
+       hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
+       hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_DIAG);
 
        /* Set up the quality report callback for Intel devices */
        hdev->set_quality_report = btintel_set_quality_report;
@@ -2123,7 +2123,7 @@ static int btintel_pcie_setup_internal(struct hci_dev *hdev)
                 *
                 * All TLV based devices support WBS
                 */
-               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                /* Setup MSFT Extension support */
                btintel_set_msft_opcode(hdev,
index c16a3518b8ffa4e8683e7fbf586c121421954c6d..4fc673640bfce806b437e97349b8cc3301b12bc6 100644 (file)
@@ -1141,7 +1141,7 @@ static int btmtksdio_setup(struct hci_dev *hdev)
                }
 
                /* Enable WBS with mSBC codec */
-               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                /* Enable GPIO reset mechanism */
                if (bdev->reset) {
@@ -1384,7 +1384,7 @@ static int btmtksdio_probe(struct sdio_func *func,
        SET_HCIDEV_DEV(hdev, &func->dev);
 
        hdev->manufacturer = 70;
-       set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
 
        sdio_set_drvdata(func, bdev);
 
index c97e260fcb0c3056419f6aaf429602ce36f664ae..51400a891f6e6dc28603d3ce8e96ec3d3ead3990 100644 (file)
@@ -872,7 +872,7 @@ static int btmtkuart_probe(struct serdev_device *serdev)
        SET_HCIDEV_DEV(hdev, &serdev->dev);
 
        hdev->manufacturer = 70;
-       set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
 
        if (btmtkuart_is_standalone(bdev)) {
                err = clk_prepare_enable(bdev->osc);
index 1088db6056a4a2af6a3698f682c95ebd125b1170..24f9b52605a1b3a6e79d563211baa8daa30d50f2 100644 (file)
@@ -1807,7 +1807,7 @@ static int nxp_serdev_probe(struct serdev_device *serdev)
                                      "local-bd-address",
                                      (u8 *)&ba, sizeof(ba));
        if (bacmp(&ba, BDADDR_ANY))
-               set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
 
        if (hci_register_dev(hdev) < 0) {
                dev_err(&serdev->dev, "Can't register HCI device\n");
index edefb9dc76aa1a019dc1e0ae06f4545b4ad3f96a..7c958d6065bec15aa1829d3e4b100ac9e4a568d0 100644 (file)
@@ -739,7 +739,7 @@ static int qca_check_bdaddr(struct hci_dev *hdev, const struct qca_fw_config *co
 
        bda = (struct hci_rp_read_bd_addr *)skb->data;
        if (!bacmp(&bda->bdaddr, &config->bdaddr))
-               set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
 
        kfree_skb(skb);
 
index c0eb71d6ffd3bde03299ea3bd0983129592722ac..d2e13fcb6babfcbe86da9e93326fce76c1d0d71b 100644 (file)
@@ -117,7 +117,7 @@ static int btqcomsmd_setup(struct hci_dev *hdev)
        /* Devices do not have persistent storage for BD address. Retrieve
         * it from the firmware node property.
         */
-       set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
 
        return 0;
 }
index 7838c89e529e0c7fdc9355523eba441eb82531cd..4d182cf6e037235fe3d608144ae364fef890e61d 100644 (file)
@@ -1287,7 +1287,7 @@ void btrtl_set_quirks(struct hci_dev *hdev, struct btrtl_device_info *btrtl_dev)
        /* Enable controller to do both LE scan and BR/EDR inquiry
         * simultaneously.
         */
-       set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
 
        /* Enable central-peripheral role (able to create new connections with
         * an existing connection in slave role).
@@ -1301,7 +1301,7 @@ void btrtl_set_quirks(struct hci_dev *hdev, struct btrtl_device_info *btrtl_dev)
        case CHIP_ID_8851B:
        case CHIP_ID_8922A:
        case CHIP_ID_8852BT:
-               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                /* RTL8852C needs to transmit mSBC data continuously without
                 * the zero length of USB packets for the ALT 6 supported chips
@@ -1312,7 +1312,8 @@ void btrtl_set_quirks(struct hci_dev *hdev, struct btrtl_device_info *btrtl_dev)
                if (btrtl_dev->project_id == CHIP_ID_8852A ||
                    btrtl_dev->project_id == CHIP_ID_8852B ||
                    btrtl_dev->project_id == CHIP_ID_8852C)
-                       set_bit(HCI_QUIRK_USE_MSFT_EXT_ADDRESS_FILTER, &hdev->quirks);
+                       hci_set_quirk(hdev,
+                                     HCI_QUIRK_USE_MSFT_EXT_ADDRESS_FILTER);
 
                hci_set_aosp_capable(hdev);
                break;
@@ -1331,8 +1332,7 @@ void btrtl_set_quirks(struct hci_dev *hdev, struct btrtl_device_info *btrtl_dev)
                 * but it doesn't support any features from page 2 -
                 * it either responds with garbage or with error status
                 */
-               set_bit(HCI_QUIRK_BROKEN_LOCAL_EXT_FEATURES_PAGE_2,
-                       &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LOCAL_EXT_FEATURES_PAGE_2);
                break;
        default:
                break;
index a69feb08486a5a7af0ae2344c341ee7f607788dc..8325655ce6aa81e18f75ede78442da82bcb482e6 100644 (file)
@@ -327,7 +327,7 @@ static int btsdio_probe(struct sdio_func *func,
        hdev->send     = btsdio_send_frame;
 
        if (func->vendor == 0x0104 && func->device == 0x00c5)
-               set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
 
        err = hci_register_dev(hdev);
        if (err < 0) {
index 9ab661d2d1e69028061fa3accd5106f481094100..64509f5bfc994e58990bec7d8e0931f27e951626 100644 (file)
@@ -2472,18 +2472,18 @@ static int btusb_setup_csr(struct hci_dev *hdev)
                 * Probably will need to be expanded in the future;
                 * without these the controller will lock up.
                 */
-               set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL, &hdev->quirks);
-               set_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_READ_VOICE_SETTING, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_READ_PAGE_SCAN_TYPE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_STORED_LINK_KEY);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_ERR_DATA_REPORTING);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL);
+               hci_set_quirk(hdev, HCI_QUIRK_NO_SUSPEND_NOTIFIER);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_READ_VOICE_SETTING);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_READ_PAGE_SCAN_TYPE);
 
                /* Clear the reset quirk since this is not an actual
                 * early Bluetooth 1.1 device from CSR.
                 */
-               clear_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
-               clear_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
+               hci_clear_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
+               hci_clear_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
 
                /*
                 * Special workaround for these BT 4.0 chip clones, and potentially more:
@@ -3494,7 +3494,7 @@ static int btusb_setup_qca(struct hci_dev *hdev)
        /* Mark HCI_OP_ENHANCED_SETUP_SYNC_CONN as broken as it doesn't seem to
         * work with the likes of HSP/HFP mSBC.
         */
-       set_bit(HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN);
 
        return 0;
 }
@@ -4008,10 +4008,10 @@ static int btusb_probe(struct usb_interface *intf,
        }
 #endif
        if (id->driver_info & BTUSB_CW6622)
-               set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_STORED_LINK_KEY);
 
        if (id->driver_info & BTUSB_BCM2045)
-               set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_STORED_LINK_KEY);
 
        if (id->driver_info & BTUSB_BCM92035)
                hdev->setup = btusb_setup_bcm92035;
@@ -4068,8 +4068,8 @@ static int btusb_probe(struct usb_interface *intf,
                hdev->reset = btmtk_reset_sync;
                hdev->set_bdaddr = btmtk_set_bdaddr;
                hdev->send = btusb_send_frame_mtk;
-               set_bit(HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN, &hdev->quirks);
-               set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN);
+               hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
                data->recv_acl = btmtk_usb_recv_acl;
                data->suspend = btmtk_usb_suspend;
                data->resume = btmtk_usb_resume;
@@ -4077,20 +4077,20 @@ static int btusb_probe(struct usb_interface *intf,
        }
 
        if (id->driver_info & BTUSB_SWAVE) {
-               set_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_FIXUP_INQUIRY_MODE);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LOCAL_COMMANDS);
        }
 
        if (id->driver_info & BTUSB_INTEL_BOOT) {
                hdev->manufacturer = 2;
-               set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RAW_DEVICE);
        }
 
        if (id->driver_info & BTUSB_ATH3012) {
                data->setup_on_usb = btusb_setup_qca;
                hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
-               set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
-               set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
+               hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
        }
 
        if (id->driver_info & BTUSB_QCA_ROME) {
@@ -4098,7 +4098,7 @@ static int btusb_probe(struct usb_interface *intf,
                hdev->shutdown = btusb_shutdown_qca;
                hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
                hdev->reset = btusb_qca_reset;
-               set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
                btusb_check_needs_reset_resume(intf);
        }
 
@@ -4112,7 +4112,7 @@ static int btusb_probe(struct usb_interface *intf,
                hdev->shutdown = btusb_shutdown_qca;
                hdev->set_bdaddr = btusb_set_bdaddr_wcn6855;
                hdev->reset = btusb_qca_reset;
-               set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
                hci_set_msft_opcode(hdev, 0xFD70);
        }
 
@@ -4140,35 +4140,35 @@ static int btusb_probe(struct usb_interface *intf,
 
        if (id->driver_info & BTUSB_ACTIONS_SEMI) {
                /* Support is advertised, but not implemented */
-               set_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_SET_RPA_TIMEOUT, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_EXT_CREATE_CONN, &hdev->quirks);
-               set_bit(HCI_QUIRK_BROKEN_WRITE_AUTH_PAYLOAD_TIMEOUT, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_ERR_DATA_REPORTING);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_SET_RPA_TIMEOUT);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_EXT_SCAN);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_EXT_CREATE_CONN);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_WRITE_AUTH_PAYLOAD_TIMEOUT);
        }
 
        if (!reset)
-               set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
 
        if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
                if (!disable_scofix)
-                       set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_FIXUP_BUFFER_SIZE);
        }
 
        if (id->driver_info & BTUSB_BROKEN_ISOC)
                data->isoc = NULL;
 
        if (id->driver_info & BTUSB_WIDEBAND_SPEECH)
-               set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
        if (id->driver_info & BTUSB_INVALID_LE_STATES)
-               set_bit(HCI_QUIRK_BROKEN_LE_STATES, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LE_STATES);
 
        if (id->driver_info & BTUSB_DIGIANSWER) {
                data->cmdreq_type = USB_TYPE_VENDOR;
-               set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
        }
 
        if (id->driver_info & BTUSB_CSR) {
@@ -4177,10 +4177,10 @@ static int btusb_probe(struct usb_interface *intf,
 
                /* Old firmware would otherwise execute USB reset */
                if (bcdDevice < 0x117)
-                       set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
 
                /* This must be set first in case we disable it for fakes */
-               set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
 
                /* Fake CSR devices with broken commands */
                if (le16_to_cpu(udev->descriptor.idVendor)  == 0x0a12 &&
@@ -4193,7 +4193,7 @@ static int btusb_probe(struct usb_interface *intf,
 
                /* New sniffer firmware has crippled HCI interface */
                if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
-                       set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_RAW_DEVICE);
        }
 
        if (id->driver_info & BTUSB_INTEL_BOOT) {
index 1394c575aa6d44006e4c771e3653b62447b8c382..707e90f801303341fdb74ce5aa32c7f868c59548 100644 (file)
@@ -424,7 +424,7 @@ static int aml_check_bdaddr(struct hci_dev *hdev)
 
        if (!bacmp(&paddr->bdaddr, AML_BDADDR_DEFAULT)) {
                bt_dev_info(hdev, "amlbt using default bdaddr (%pM)", &paddr->bdaddr);
-               set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
        }
 
 exit:
index 9684eb16059bb09b3e9ec002354a46b4283cee96..f96617b85d8777972137ca146ab99a3d8da12584 100644 (file)
@@ -643,8 +643,8 @@ static int bcm_setup(struct hci_uart *hu)
         * Allow the bootloader to set a valid address through the
         * device tree.
         */
-       if (test_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks))
-               set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hu->hdev->quirks);
+       if (hci_test_quirk(hu->hdev, HCI_QUIRK_INVALID_BDADDR))
+               hci_set_quirk(hu->hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
 
        if (!bcm_request_irq(bcm))
                err = bcm_setup_sleep(hu);
index 9bce53e49cfa60c6ee9ea734e5d7a0708dc7a679..8a9aa33776b030b61fac34b5cd653929406a84be 100644 (file)
@@ -1435,7 +1435,7 @@ static int bcm4377_check_bdaddr(struct bcm4377_data *bcm4377)
 
        bda = (struct hci_rp_read_bd_addr *)skb->data;
        if (!bcm4377_is_valid_bdaddr(bcm4377, &bda->bdaddr))
-               set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &bcm4377->hdev->quirks);
+               hci_set_quirk(bcm4377->hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
 
        kfree_skb(skb);
        return 0;
@@ -2389,13 +2389,13 @@ static int bcm4377_probe(struct pci_dev *pdev, const struct pci_device_id *id)
        hdev->setup = bcm4377_hci_setup;
 
        if (bcm4377->hw->broken_mws_transport_config)
-               set_bit(HCI_QUIRK_BROKEN_MWS_TRANSPORT_CONFIG, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_MWS_TRANSPORT_CONFIG);
        if (bcm4377->hw->broken_ext_scan)
-               set_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_EXT_SCAN);
        if (bcm4377->hw->broken_le_coded)
-               set_bit(HCI_QUIRK_BROKEN_LE_CODED, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LE_CODED);
        if (bcm4377->hw->broken_le_ext_adv_report_phy)
-               set_bit(HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY);
 
        pci_set_drvdata(pdev, bcm4377);
        hci_set_drvdata(hdev, bcm4377);
index 811f33701f847736ac6ac18b435d06c962a33662..d22fbb7f9fc5e1c6778698677a7e05d81d5f095f 100644 (file)
@@ -660,7 +660,7 @@ static int intel_setup(struct hci_uart *hu)
         */
        if (!bacmp(&params.otp_bdaddr, BDADDR_ANY)) {
                bt_dev_info(hdev, "No device address configured");
-               set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_INVALID_BDADDR);
        }
 
        /* With this Intel bootloader only the hardware variant and device
index acba83156de9a6a386079c7271c5e763b4ca5e31..d0adae3267b41e3f9ce919b2986697428e130025 100644 (file)
@@ -667,13 +667,13 @@ static int hci_uart_register_dev(struct hci_uart *hu)
        SET_HCIDEV_DEV(hdev, hu->tty->dev);
 
        if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
-               set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RAW_DEVICE);
 
        if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
-               set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG);
 
        if (!test_bit(HCI_UART_RESET_ON_INIT, &hu->hdev_flags))
-               set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE);
 
        /* Only call open() for the protocol after hdev is fully initialized as
         * open() (or a timer/workqueue it starts) may attempt to reference it.
index e19e9bd49555645fef6c877170629c0b97d02571..7044c86325cedc571cf4df5a03ed8baab7c09c60 100644 (file)
@@ -649,11 +649,11 @@ static int ll_setup(struct hci_uart *hu)
                /* This means that there was an error getting the BD address
                 * during probe, so mark the device as having a bad address.
                 */
-               set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
+               hci_set_quirk(hu->hdev, HCI_QUIRK_INVALID_BDADDR);
        } else if (bacmp(&lldev->bdaddr, BDADDR_ANY)) {
                err = ll_set_bdaddr(hu->hdev, &lldev->bdaddr);
                if (err)
-                       set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
+                       hci_set_quirk(hu->hdev, HCI_QUIRK_INVALID_BDADDR);
        }
 
        /* Operational speed if any */
index 9fc10a16fd962ddaa52586ce8248c60d0a244373..cd7575c20f653f580ccb6d646061b808b6be9583 100644 (file)
@@ -439,7 +439,7 @@ static int nokia_setup(struct hci_uart *hu)
 
        if (btdev->man_id == NOKIA_ID_BCM2048) {
                hu->hdev->set_bdaddr = btbcm_set_bdaddr;
-               set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
+               hci_set_quirk(hu->hdev, HCI_QUIRK_INVALID_BDADDR);
                dev_dbg(dev, "bcm2048 has invalid bluetooth address!");
        }
 
index 3ec0be496820eff8a4860df730e6796ae8eb1363..33c43503714b8ab6f5cb240423ab480aa17c32ec 100644 (file)
@@ -1892,7 +1892,7 @@ static int qca_setup(struct hci_uart *hu)
        /* Enable controller to do both LE scan and BR/EDR inquiry
         * simultaneously.
         */
-       set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
 
        switch (soc_type) {
        case QCA_QCA2066:
@@ -1944,7 +1944,7 @@ retry:
        case QCA_WCN7850:
                qcadev = serdev_device_get_drvdata(hu->serdev);
                if (qcadev->bdaddr_property_broken)
-                       set_bit(HCI_QUIRK_BDADDR_PROPERTY_BROKEN, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_BDADDR_PROPERTY_BROKEN);
 
                hci_set_aosp_capable(hdev);
 
@@ -2487,7 +2487,7 @@ static int qca_serdev_probe(struct serdev_device *serdev)
        hdev = qcadev->serdev_hu.hdev;
 
        if (power_ctrl_enabled) {
-               set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
                hdev->shutdown = qca_power_off;
        }
 
@@ -2496,11 +2496,11 @@ static int qca_serdev_probe(struct serdev_device *serdev)
                 * be queried via hci. Same with the valid le states quirk.
                 */
                if (data->capabilities & QCA_CAP_WIDEBAND_SPEECH)
-                       set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED,
-                               &hdev->quirks);
+                       hci_set_quirk(hdev,
+                                     HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
 
                if (!(data->capabilities & QCA_CAP_VALID_LE_STATES))
-                       set_bit(HCI_QUIRK_BROKEN_LE_STATES, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_BROKEN_LE_STATES);
        }
 
        return 0;
@@ -2550,7 +2550,7 @@ static void qca_serdev_shutdown(struct device *dev)
                 * invoked and the SOC is already in the initial state, so
                 * don't also need to send the VSC.
                 */
-               if (test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks) ||
+               if (hci_test_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP) ||
                    hci_dev_test_flag(hdev, HCI_SETUP))
                        return;
 
index 89a22e9b3253a8605fe19e652a7a8f0498d4b5df..593d9cefbbf925b4d3f8d37a12420a99e08a9477 100644 (file)
@@ -152,7 +152,7 @@ static int hci_uart_close(struct hci_dev *hdev)
         * BT SOC is completely powered OFF during BT OFF, holding port
         * open may drain the battery.
         */
-       if (test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) {
+       if (hci_test_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP)) {
                clear_bit(HCI_UART_PROTO_READY, &hu->flags);
                serdev_device_close(hu->serdev);
        }
@@ -358,13 +358,13 @@ int hci_uart_register_device_priv(struct hci_uart *hu,
        SET_HCIDEV_DEV(hdev, &hu->serdev->dev);
 
        if (test_bit(HCI_UART_NO_SUSPEND_NOTIFIER, &hu->flags))
-               set_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_NO_SUSPEND_NOTIFIER);
 
        if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags))
-               set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RAW_DEVICE);
 
        if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags))
-               set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG);
 
        if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags))
                return 0;
index 59f4d7bdffdcb58b6f7ef8cbb24a64a3f507103c..f7d8c3c00655a82f16b36775803590f0306eae0c 100644 (file)
@@ -415,16 +415,16 @@ static int __vhci_create_device(struct vhci_data *data, __u8 opcode)
        hdev->get_codec_config_data = vhci_get_codec_config_data;
        hdev->wakeup = vhci_wakeup;
        hdev->setup = vhci_setup;
-       set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
-       set_bit(HCI_QUIRK_SYNC_FLOWCTL_SUPPORTED, &hdev->quirks);
+       hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
+       hci_set_quirk(hdev, HCI_QUIRK_SYNC_FLOWCTL_SUPPORTED);
 
        /* bit 6 is for external configuration */
        if (opcode & 0x40)
-               set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG);
 
        /* bit 7 is for raw device */
        if (opcode & 0x80)
-               set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
+               hci_set_quirk(hdev, HCI_QUIRK_RAW_DEVICE);
 
        if (hci_register_dev(hdev) < 0) {
                BT_ERR("Can't register HCI device");
index 756f292df9e87dd9910d029a72cbf18345f1140f..6f1a37e85c6a476bb66dbaa57b2b2bb169fc0889 100644 (file)
@@ -327,17 +327,17 @@ static int virtbt_probe(struct virtio_device *vdev)
                        hdev->setup = virtbt_setup_intel;
                        hdev->shutdown = virtbt_shutdown_generic;
                        hdev->set_bdaddr = virtbt_set_bdaddr_intel;
-                       set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
-                       set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
-                       set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER);
+                       hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
+                       hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
                        break;
 
                case VIRTIO_BT_CONFIG_VENDOR_REALTEK:
                        hdev->manufacturer = 93;
                        hdev->setup = virtbt_setup_realtek;
                        hdev->shutdown = virtbt_shutdown_generic;
-                       set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
-                       set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
+                       hci_set_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
+                       hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
                        break;
                }
        }
index 82cbd54443acb4fe9222a6451b1612e8d89af7ae..c79901f2dc2a0483526f36d643fcdc88f3024aae 100644 (file)
@@ -377,6 +377,8 @@ enum {
         * This quirk must be set before hci_register_dev is called.
         */
        HCI_QUIRK_BROKEN_READ_PAGE_SCAN_TYPE,
+
+       __HCI_NUM_QUIRKS,
 };
 
 /* HCI device flags */
index 367ca43f45d1116d1ffcc35c75e87a1d6370160f..f79f59e67114b3b50e4ca8919f7ca9f146c43a37 100644 (file)
@@ -464,7 +464,7 @@ struct hci_dev {
 
        unsigned int    auto_accept_delay;
 
-       unsigned long   quirks;
+       DECLARE_BITMAP(quirk_flags, __HCI_NUM_QUIRKS);
 
        atomic_t        cmd_cnt;
        unsigned int    acl_cnt;
@@ -656,6 +656,10 @@ struct hci_dev {
        u8 (*classify_pkt_type)(struct hci_dev *hdev, struct sk_buff *skb);
 };
 
+#define hci_set_quirk(hdev, nr) set_bit((nr), (hdev)->quirk_flags)
+#define hci_clear_quirk(hdev, nr) clear_bit((nr), (hdev)->quirk_flags)
+#define hci_test_quirk(hdev, nr) test_bit((nr), (hdev)->quirk_flags)
+
 #define HCI_PHY_HANDLE(handle) (handle & 0xff)
 
 enum conn_reasons {
@@ -839,7 +843,7 @@ extern struct mutex hci_cb_list_lock;
        } while (0)
 
 #define hci_dev_le_state_simultaneous(hdev) \
-       (!test_bit(HCI_QUIRK_BROKEN_LE_STATES, &(hdev)->quirks) && \
+       (!hci_test_quirk((hdev), HCI_QUIRK_BROKEN_LE_STATES) && \
         ((hdev)->le_states[4] & 0x08) &&       /* Central */ \
         ((hdev)->le_states[4] & 0x40) &&       /* Peripheral */ \
         ((hdev)->le_states[3] & 0x10))         /* Simultaneous */
@@ -1931,8 +1935,8 @@ void hci_conn_del_sysfs(struct hci_conn *conn);
                      ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
 
 #define le_coded_capable(dev) (((dev)->le_features[1] & HCI_LE_PHY_CODED) && \
-                              !test_bit(HCI_QUIRK_BROKEN_LE_CODED, \
-                                        &(dev)->quirks))
+                              !hci_test_quirk((dev), \
+                                              HCI_QUIRK_BROKEN_LE_CODED))
 
 #define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
                         ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
@@ -1944,27 +1948,27 @@ void hci_conn_del_sysfs(struct hci_conn *conn);
 
 #define read_key_size_capable(dev) \
        ((dev)->commands[20] & 0x10 && \
-        !test_bit(HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE, &(dev)->quirks))
+        !hci_test_quirk((dev), HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE))
 
 #define read_voice_setting_capable(dev) \
        ((dev)->commands[9] & 0x04 && \
-        !test_bit(HCI_QUIRK_BROKEN_READ_VOICE_SETTING, &(dev)->quirks))
+        !hci_test_quirk((dev), HCI_QUIRK_BROKEN_READ_VOICE_SETTING))
 
 /* Use enhanced synchronous connection if command is supported and its quirk
  * has not been set.
  */
 #define enhanced_sync_conn_capable(dev) \
        (((dev)->commands[29] & 0x08) && \
-        !test_bit(HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN, &(dev)->quirks))
+        !hci_test_quirk((dev), HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN))
 
 /* Use ext scanning if set ext scan param and ext scan enable is supported */
 #define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
                           ((dev)->commands[37] & 0x40) && \
-                          !test_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &(dev)->quirks))
+                          !hci_test_quirk((dev), HCI_QUIRK_BROKEN_EXT_SCAN))
 
 /* Use ext create connection if command is supported */
 #define use_ext_conn(dev) (((dev)->commands[37] & 0x80) && \
-       !test_bit(HCI_QUIRK_BROKEN_EXT_CREATE_CONN, &(dev)->quirks))
+       !hci_test_quirk((dev), HCI_QUIRK_BROKEN_EXT_CREATE_CONN))
 /* Extended advertising support */
 #define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
 
@@ -1979,8 +1983,8 @@ void hci_conn_del_sysfs(struct hci_conn *conn);
  */
 #define use_enhanced_conn_complete(dev) ((ll_privacy_capable(dev) || \
                                         ext_adv_capable(dev)) && \
-                                        !test_bit(HCI_QUIRK_BROKEN_EXT_CREATE_CONN, \
-                                                &(dev)->quirks))
+                                        !hci_test_quirk((dev), \
+                                                        HCI_QUIRK_BROKEN_EXT_CREATE_CONN))
 
 /* Periodic advertising support */
 #define per_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_PERIODIC_ADV))
@@ -1997,7 +2001,7 @@ void hci_conn_del_sysfs(struct hci_conn *conn);
 #define sync_recv_capable(dev) ((dev)->le_features[3] & HCI_LE_ISO_SYNC_RECEIVER)
 
 #define mws_transport_config_capable(dev) (((dev)->commands[30] & 0x08) && \
-       (!test_bit(HCI_QUIRK_BROKEN_MWS_TRANSPORT_CONFIG, &(dev)->quirks)))
+       (!hci_test_quirk((dev), HCI_QUIRK_BROKEN_MWS_TRANSPORT_CONFIG)))
 
 /* ----- HCI protocols ----- */
 #define HCI_PROTO_DEFER             0x01
index 14d7221b8ac08a35349825f8ff25318ced3fdbde..441cb1700f9972ad82f638c5fd551a3cff7f3c50 100644 (file)
@@ -2654,7 +2654,7 @@ int hci_register_dev(struct hci_dev *hdev)
        /* Devices that are marked for raw-only usage are unconfigured
         * and should not be included in normal operation.
         */
-       if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_RAW_DEVICE))
                hci_dev_set_flag(hdev, HCI_UNCONFIGURED);
 
        /* Mark Remote Wakeup connection flag as supported if driver has wakeup
@@ -2784,7 +2784,7 @@ int hci_register_suspend_notifier(struct hci_dev *hdev)
        int ret = 0;
 
        if (!hdev->suspend_notifier.notifier_call &&
-           !test_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks)) {
+           !hci_test_quirk(hdev, HCI_QUIRK_NO_SUSPEND_NOTIFIER)) {
                hdev->suspend_notifier.notifier_call = hci_suspend_notifier;
                ret = register_pm_notifier(&hdev->suspend_notifier);
        }
index f625074d1f00201bf765a678765619d20e7a301c..99e2e9fc70e8c254bcaee8c58a7eab36e39199b0 100644 (file)
@@ -38,7 +38,7 @@ static ssize_t __name ## _read(struct file *file,                           \
        struct hci_dev *hdev = file->private_data;                            \
        char buf[3];                                                          \
                                                                              \
-       buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N';                \
+       buf[0] = test_bit(__quirk, hdev->quirk_flags) ? 'Y' : 'N';            \
        buf[1] = '\n';                                                        \
        buf[2] = '\0';                                                        \
        return simple_read_from_buffer(user_buf, count, ppos, buf, 2);        \
@@ -59,10 +59,10 @@ static ssize_t __name ## _write(struct file *file,                        \
        if (err)                                                              \
                return err;                                                   \
                                                                              \
-       if (enable == test_bit(__quirk, &hdev->quirks))                       \
+       if (enable == test_bit(__quirk, hdev->quirk_flags))                   \
                return -EALREADY;                                             \
                                                                              \
-       change_bit(__quirk, &hdev->quirks);                                   \
+       change_bit(__quirk, hdev->quirk_flags);                               \
                                                                              \
        return count;                                                         \
 }                                                                            \
@@ -1356,7 +1356,7 @@ static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf,
         * for the vendor callback. Instead just store the desired value and
         * the setting will be programmed when the controller gets powered on.
         */
-       if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) &&
+       if (hci_test_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_DIAG) &&
            (!test_bit(HCI_RUNNING, &hdev->flags) ||
             hci_dev_test_flag(hdev, HCI_USER_CHANNEL)))
                goto done;
index 992131f88a45687debbafd95b1354cf5f56996c9..cf4b30ac9e0e57f3acaa42af9a7fc4dbecef58d0 100644 (file)
@@ -908,8 +908,8 @@ static u8 hci_cc_read_local_ext_features(struct hci_dev *hdev, void *data,
                return rp->status;
 
        if (hdev->max_page < rp->max_page) {
-               if (test_bit(HCI_QUIRK_BROKEN_LOCAL_EXT_FEATURES_PAGE_2,
-                            &hdev->quirks))
+               if (hci_test_quirk(hdev,
+                                  HCI_QUIRK_BROKEN_LOCAL_EXT_FEATURES_PAGE_2))
                        bt_dev_warn(hdev, "broken local ext features page 2");
                else
                        hdev->max_page = rp->max_page;
@@ -936,7 +936,7 @@ static u8 hci_cc_read_buffer_size(struct hci_dev *hdev, void *data,
        hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
        hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
 
-       if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
+       if (hci_test_quirk(hdev, HCI_QUIRK_FIXUP_BUFFER_SIZE)) {
                hdev->sco_mtu  = 64;
                hdev->sco_pkts = 8;
        }
@@ -2971,7 +2971,7 @@ static void hci_inquiry_complete_evt(struct hci_dev *hdev, void *data,
                 * state to indicate completion.
                 */
                if (!hci_dev_test_flag(hdev, HCI_LE_SCAN) ||
-                   !test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks))
+                   !hci_test_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY))
                        hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
                goto unlock;
        }
@@ -2990,7 +2990,7 @@ static void hci_inquiry_complete_evt(struct hci_dev *hdev, void *data,
                 * state to indicate completion.
                 */
                if (!hci_dev_test_flag(hdev, HCI_LE_SCAN) ||
-                   !test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks))
+                   !hci_test_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY))
                        hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
        }
 
@@ -3614,8 +3614,7 @@ static void hci_encrypt_change_evt(struct hci_dev *hdev, void *data,
        /* We skip the WRITE_AUTH_PAYLOAD_TIMEOUT for ATS2851 based controllers
         * to avoid unexpected SMP command errors when pairing.
         */
-       if (test_bit(HCI_QUIRK_BROKEN_WRITE_AUTH_PAYLOAD_TIMEOUT,
-                    &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_BROKEN_WRITE_AUTH_PAYLOAD_TIMEOUT))
                goto notify;
 
        /* Set the default Authenticated Payload Timeout after
@@ -5914,7 +5913,7 @@ static struct hci_conn *check_pending_le_conn(struct hci_dev *hdev,
         * while we have an existing one in peripheral role.
         */
        if (hdev->conn_hash.le_num_peripheral > 0 &&
-           (test_bit(HCI_QUIRK_BROKEN_LE_STATES, &hdev->quirks) ||
+           (hci_test_quirk(hdev, HCI_QUIRK_BROKEN_LE_STATES) ||
             !(hdev->le_states[3] & 0x10)))
                return NULL;
 
@@ -6310,8 +6309,8 @@ static void hci_le_ext_adv_report_evt(struct hci_dev *hdev, void *data,
                evt_type = __le16_to_cpu(info->type) & LE_EXT_ADV_EVT_TYPE_MASK;
                legacy_evt_type = ext_evt_type_to_legacy(hdev, evt_type);
 
-               if (test_bit(HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY,
-                            &hdev->quirks)) {
+               if (hci_test_quirk(hdev,
+                                  HCI_QUIRK_FIXUP_LE_EXT_ADV_REPORT_PHY)) {
                        info->primary_phy &= 0x1f;
                        info->secondary_phy &= 0x1f;
                }
index acbf06aa3dd73ae72be94268ebc4f6afa3f9a9bd..7938c004071c497d87cda684f5852f1f05d77bad 100644 (file)
@@ -393,7 +393,7 @@ static void le_scan_disable(struct work_struct *work)
        if (hdev->discovery.type != DISCOV_TYPE_INTERLEAVED)
                goto _return;
 
-       if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks)) {
+       if (hci_test_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY)) {
                if (!test_bit(HCI_INQUIRY, &hdev->flags) &&
                    hdev->discovery.state != DISCOVERY_RESOLVING)
                        goto discov_stopped;
@@ -3587,7 +3587,7 @@ static void hci_dev_get_bd_addr_from_property(struct hci_dev *hdev)
        if (ret < 0 || !bacmp(&ba, BDADDR_ANY))
                return;
 
-       if (test_bit(HCI_QUIRK_BDADDR_PROPERTY_BROKEN, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_BDADDR_PROPERTY_BROKEN))
                baswap(&hdev->public_addr, &ba);
        else
                bacpy(&hdev->public_addr, &ba);
@@ -3662,7 +3662,7 @@ static int hci_init0_sync(struct hci_dev *hdev)
        bt_dev_dbg(hdev, "");
 
        /* Reset */
-       if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) {
+       if (!hci_test_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE)) {
                err = hci_reset_sync(hdev);
                if (err)
                        return err;
@@ -3675,7 +3675,7 @@ static int hci_unconf_init_sync(struct hci_dev *hdev)
 {
        int err;
 
-       if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_RAW_DEVICE))
                return 0;
 
        err = hci_init0_sync(hdev);
@@ -3718,7 +3718,7 @@ static int hci_read_local_cmds_sync(struct hci_dev *hdev)
         * supported commands.
         */
        if (hdev->hci_ver > BLUETOOTH_VER_1_1 &&
-           !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks))
+           !hci_test_quirk(hdev, HCI_QUIRK_BROKEN_LOCAL_COMMANDS))
                return __hci_cmd_sync_status(hdev, HCI_OP_READ_LOCAL_COMMANDS,
                                             0, NULL, HCI_CMD_TIMEOUT);
 
@@ -3732,7 +3732,7 @@ static int hci_init1_sync(struct hci_dev *hdev)
        bt_dev_dbg(hdev, "");
 
        /* Reset */
-       if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) {
+       if (!hci_test_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE)) {
                err = hci_reset_sync(hdev);
                if (err)
                        return err;
@@ -3795,7 +3795,7 @@ static int hci_set_event_filter_sync(struct hci_dev *hdev, u8 flt_type,
        if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
                return 0;
 
-       if (test_bit(HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL))
                return 0;
 
        memset(&cp, 0, sizeof(cp));
@@ -3822,7 +3822,7 @@ static int hci_clear_event_filter_sync(struct hci_dev *hdev)
         * a hci_set_event_filter_sync() call succeeds, but we do
         * the check both for parity and as a future reminder.
         */
-       if (test_bit(HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL))
                return 0;
 
        return hci_set_event_filter_sync(hdev, HCI_FLT_CLEAR_ALL, 0x00,
@@ -3846,7 +3846,7 @@ static int hci_write_sync_flowctl_sync(struct hci_dev *hdev)
 
        /* Check if the controller supports SCO and HCI_OP_WRITE_SYNC_FLOWCTL */
        if (!lmp_sco_capable(hdev) || !(hdev->commands[10] & BIT(4)) ||
-           !test_bit(HCI_QUIRK_SYNC_FLOWCTL_SUPPORTED, &hdev->quirks))
+           !hci_test_quirk(hdev, HCI_QUIRK_SYNC_FLOWCTL_SUPPORTED))
                return 0;
 
        memset(&cp, 0, sizeof(cp));
@@ -3921,7 +3921,7 @@ static int hci_write_inquiry_mode_sync(struct hci_dev *hdev)
        u8 mode;
 
        if (!lmp_inq_rssi_capable(hdev) &&
-           !test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks))
+           !hci_test_quirk(hdev, HCI_QUIRK_FIXUP_INQUIRY_MODE))
                return 0;
 
        /* If Extended Inquiry Result events are supported, then
@@ -4111,7 +4111,7 @@ static int hci_set_event_mask_sync(struct hci_dev *hdev)
        }
 
        if (lmp_inq_rssi_capable(hdev) ||
-           test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_FIXUP_INQUIRY_MODE))
                events[4] |= 0x02; /* Inquiry Result with RSSI */
 
        if (lmp_ext_feat_capable(hdev))
@@ -4163,7 +4163,7 @@ static int hci_read_stored_link_key_sync(struct hci_dev *hdev)
        struct hci_cp_read_stored_link_key cp;
 
        if (!(hdev->commands[6] & 0x20) ||
-           test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_STORED_LINK_KEY))
                return 0;
 
        memset(&cp, 0, sizeof(cp));
@@ -4212,7 +4212,7 @@ static int hci_read_def_err_data_reporting_sync(struct hci_dev *hdev)
 {
        if (!(hdev->commands[18] & 0x04) ||
            !(hdev->features[0][6] & LMP_ERR_DATA_REPORTING) ||
-           test_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_ERR_DATA_REPORTING))
                return 0;
 
        return __hci_cmd_sync_status(hdev, HCI_OP_READ_DEF_ERR_DATA_REPORTING,
@@ -4226,7 +4226,7 @@ static int hci_read_page_scan_type_sync(struct hci_dev *hdev)
         * this command in the bit mask of supported commands.
         */
        if (!(hdev->commands[13] & 0x01) ||
-           test_bit(HCI_QUIRK_BROKEN_READ_PAGE_SCAN_TYPE, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_READ_PAGE_SCAN_TYPE))
                return 0;
 
        return __hci_cmd_sync_status(hdev, HCI_OP_READ_PAGE_SCAN_TYPE,
@@ -4421,7 +4421,7 @@ static int hci_le_read_adv_tx_power_sync(struct hci_dev *hdev)
 static int hci_le_read_tx_power_sync(struct hci_dev *hdev)
 {
        if (!(hdev->commands[38] & 0x80) ||
-           test_bit(HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_READ_TRANSMIT_POWER))
                return 0;
 
        return __hci_cmd_sync_status(hdev, HCI_OP_LE_READ_TRANSMIT_POWER,
@@ -4464,7 +4464,7 @@ static int hci_le_set_rpa_timeout_sync(struct hci_dev *hdev)
        __le16 timeout = cpu_to_le16(hdev->rpa_timeout);
 
        if (!(hdev->commands[35] & 0x04) ||
-           test_bit(HCI_QUIRK_BROKEN_SET_RPA_TIMEOUT, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_SET_RPA_TIMEOUT))
                return 0;
 
        return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_RPA_TIMEOUT,
@@ -4609,7 +4609,7 @@ static int hci_delete_stored_link_key_sync(struct hci_dev *hdev)
         * just disable this command.
         */
        if (!(hdev->commands[6] & 0x80) ||
-           test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_STORED_LINK_KEY))
                return 0;
 
        memset(&cp, 0, sizeof(cp));
@@ -4735,7 +4735,7 @@ static int hci_set_err_data_report_sync(struct hci_dev *hdev)
 
        if (!(hdev->commands[18] & 0x08) ||
            !(hdev->features[0][6] & LMP_ERR_DATA_REPORTING) ||
-           test_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks))
+           hci_test_quirk(hdev, HCI_QUIRK_BROKEN_ERR_DATA_REPORTING))
                return 0;
 
        if (enabled == hdev->err_data_reporting)
@@ -4948,7 +4948,7 @@ static int hci_dev_setup_sync(struct hci_dev *hdev)
        size_t i;
 
        if (!hci_dev_test_flag(hdev, HCI_SETUP) &&
-           !test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks))
+           !hci_test_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP))
                return 0;
 
        bt_dev_dbg(hdev, "");
@@ -4959,7 +4959,7 @@ static int hci_dev_setup_sync(struct hci_dev *hdev)
                ret = hdev->setup(hdev);
 
        for (i = 0; i < ARRAY_SIZE(hci_broken_table); i++) {
-               if (test_bit(hci_broken_table[i].quirk, &hdev->quirks))
+               if (hci_test_quirk(hdev, hci_broken_table[i].quirk))
                        bt_dev_warn(hdev, "%s", hci_broken_table[i].desc);
        }
 
@@ -4967,10 +4967,10 @@ static int hci_dev_setup_sync(struct hci_dev *hdev)
         * BD_ADDR invalid before creating the HCI device or in
         * its setup callback.
         */
-       invalid_bdaddr = test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) ||
-                        test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks);
+       invalid_bdaddr = hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
+                        hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
        if (!ret) {
-               if (test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks) &&
+               if (hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) &&
                    !bacmp(&hdev->public_addr, BDADDR_ANY))
                        hci_dev_get_bd_addr_from_property(hdev);
 
@@ -4992,7 +4992,7 @@ static int hci_dev_setup_sync(struct hci_dev *hdev)
         * In case any of them is set, the controller has to
         * start up as unconfigured.
         */
-       if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) ||
+       if (hci_test_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG) ||
            invalid_bdaddr)
                hci_dev_set_flag(hdev, HCI_UNCONFIGURED);
 
@@ -5052,7 +5052,7 @@ static int hci_dev_init_sync(struct hci_dev *hdev)
         * then they need to be reprogrammed after the init procedure
         * completed.
         */
-       if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) &&
+       if (hci_test_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_DIAG) &&
            !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) &&
            hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag)
                ret = hdev->set_diag(hdev, true);
@@ -5309,7 +5309,7 @@ int hci_dev_close_sync(struct hci_dev *hdev)
        /* Reset device */
        skb_queue_purge(&hdev->cmd_q);
        atomic_set(&hdev->cmd_cnt, 1);
-       if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) &&
+       if (hci_test_quirk(hdev, HCI_QUIRK_RESET_ON_CLOSE) &&
            !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) {
                set_bit(HCI_INIT, &hdev->flags);
                hci_reset_sync(hdev);
@@ -5959,7 +5959,7 @@ static int hci_active_scan_sync(struct hci_dev *hdev, uint16_t interval)
                own_addr_type = ADDR_LE_DEV_PUBLIC;
 
        if (hci_is_adv_monitoring(hdev) ||
-           (test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) &&
+           (hci_test_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER) &&
            hdev->discovery.result_filtering)) {
                /* Duplicate filter should be disabled when some advertisement
                 * monitor is activated, otherwise AdvMon can only receive one
@@ -6022,8 +6022,7 @@ int hci_start_discovery_sync(struct hci_dev *hdev)
                 * and LE scanning are done sequentially with separate
                 * timeouts.
                 */
-               if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY,
-                            &hdev->quirks)) {
+               if (hci_test_quirk(hdev, HCI_QUIRK_SIMULTANEOUS_DISCOVERY)) {
                        timeout = msecs_to_jiffies(DISCOV_LE_TIMEOUT);
                        /* During simultaneous discovery, we double LE scan
                         * interval. We must leave some time for the controller
@@ -6100,7 +6099,7 @@ static int hci_update_event_filter_sync(struct hci_dev *hdev)
        /* Some fake CSR controllers lock up after setting this type of
         * filter, so avoid sending the request altogether.
         */
-       if (test_bit(HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_BROKEN_FILTER_CLEAR_ALL))
                return 0;
 
        /* Always clear event filter when starting */
index 1485b455ade46483ea31b7a02e0dabee088a0010..63dba0503653bd18c73b382b7afe4d06b5f42b25 100644 (file)
@@ -464,7 +464,7 @@ static int read_index_list(struct sock *sk, struct hci_dev *hdev, void *data,
                /* Devices marked as raw-only are neither configured
                 * nor unconfigured controllers.
                 */
-               if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks))
+               if (hci_test_quirk(d, HCI_QUIRK_RAW_DEVICE))
                        continue;
 
                if (!hci_dev_test_flag(d, HCI_UNCONFIGURED)) {
@@ -522,7 +522,7 @@ static int read_unconf_index_list(struct sock *sk, struct hci_dev *hdev,
                /* Devices marked as raw-only are neither configured
                 * nor unconfigured controllers.
                 */
-               if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks))
+               if (hci_test_quirk(d, HCI_QUIRK_RAW_DEVICE))
                        continue;
 
                if (hci_dev_test_flag(d, HCI_UNCONFIGURED)) {
@@ -576,7 +576,7 @@ static int read_ext_index_list(struct sock *sk, struct hci_dev *hdev,
                /* Devices marked as raw-only are neither configured
                 * nor unconfigured controllers.
                 */
-               if (test_bit(HCI_QUIRK_RAW_DEVICE, &d->quirks))
+               if (hci_test_quirk(d, HCI_QUIRK_RAW_DEVICE))
                        continue;
 
                if (hci_dev_test_flag(d, HCI_UNCONFIGURED))
@@ -612,12 +612,12 @@ static int read_ext_index_list(struct sock *sk, struct hci_dev *hdev,
 
 static bool is_configured(struct hci_dev *hdev)
 {
-       if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) &&
+       if (hci_test_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG) &&
            !hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED))
                return false;
 
-       if ((test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) ||
-            test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) &&
+       if ((hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
+            hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY)) &&
            !bacmp(&hdev->public_addr, BDADDR_ANY))
                return false;
 
@@ -628,12 +628,12 @@ static __le32 get_missing_options(struct hci_dev *hdev)
 {
        u32 options = 0;
 
-       if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) &&
+       if (hci_test_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG) &&
            !hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED))
                options |= MGMT_OPTION_EXTERNAL_CONFIG;
 
-       if ((test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) ||
-            test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) &&
+       if ((hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
+            hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY)) &&
            !bacmp(&hdev->public_addr, BDADDR_ANY))
                options |= MGMT_OPTION_PUBLIC_ADDRESS;
 
@@ -669,7 +669,7 @@ static int read_config_info(struct sock *sk, struct hci_dev *hdev,
        memset(&rp, 0, sizeof(rp));
        rp.manufacturer = cpu_to_le16(hdev->manufacturer);
 
-       if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG))
                options |= MGMT_OPTION_EXTERNAL_CONFIG;
 
        if (hdev->set_bdaddr)
@@ -828,8 +828,7 @@ static u32 get_supported_settings(struct hci_dev *hdev)
                if (lmp_sc_capable(hdev))
                        settings |= MGMT_SETTING_SECURE_CONN;
 
-               if (test_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED,
-                            &hdev->quirks))
+               if (hci_test_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED))
                        settings |= MGMT_SETTING_WIDEBAND_SPEECH;
        }
 
@@ -841,8 +840,7 @@ static u32 get_supported_settings(struct hci_dev *hdev)
                settings |= MGMT_SETTING_ADVERTISING;
        }
 
-       if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) ||
-           hdev->set_bdaddr)
+       if (hci_test_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG) || hdev->set_bdaddr)
                settings |= MGMT_SETTING_CONFIGURATION;
 
        if (cis_central_capable(hdev))
@@ -4307,7 +4305,7 @@ static int set_wideband_speech(struct sock *sk, struct hci_dev *hdev,
 
        bt_dev_dbg(hdev, "sock %p", sk);
 
-       if (!test_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks))
+       if (!hci_test_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED))
                return mgmt_cmd_status(sk, hdev->id,
                                       MGMT_OP_SET_WIDEBAND_SPEECH,
                                       MGMT_STATUS_NOT_SUPPORTED);
@@ -7935,7 +7933,7 @@ static int set_external_config(struct sock *sk, struct hci_dev *hdev,
                return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_EXTERNAL_CONFIG,
                                         MGMT_STATUS_INVALID_PARAMS);
 
-       if (!test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks))
+       if (!hci_test_quirk(hdev, HCI_QUIRK_EXTERNAL_CONFIG))
                return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_EXTERNAL_CONFIG,
                                       MGMT_STATUS_NOT_SUPPORTED);
 
@@ -9338,7 +9336,7 @@ void mgmt_index_added(struct hci_dev *hdev)
 {
        struct mgmt_ev_ext_index ev;
 
-       if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_RAW_DEVICE))
                return;
 
        if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) {
@@ -9362,7 +9360,7 @@ void mgmt_index_removed(struct hci_dev *hdev)
        struct mgmt_ev_ext_index ev;
        struct cmd_lookup match = { NULL, hdev, MGMT_STATUS_INVALID_INDEX };
 
-       if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
+       if (hci_test_quirk(hdev, HCI_QUIRK_RAW_DEVICE))
                return;
 
        mgmt_pending_foreach(0, hdev, true, cmd_complete_rsp, &match);
@@ -10089,7 +10087,7 @@ static bool is_filter_match(struct hci_dev *hdev, s8 rssi, u8 *eir,
        if (hdev->discovery.rssi != HCI_RSSI_INVALID &&
            (rssi == HCI_RSSI_INVALID ||
            (rssi < hdev->discovery.rssi &&
-            !test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks))))
+            !hci_test_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER))))
                return  false;
 
        if (hdev->discovery.uuid_count != 0) {
@@ -10107,7 +10105,7 @@ static bool is_filter_match(struct hci_dev *hdev, s8 rssi, u8 *eir,
        /* If duplicate filtering does not report RSSI changes, then restart
         * scanning to ensure updated result with updated RSSI values.
         */
-       if (test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks)) {
+       if (hci_test_quirk(hdev, HCI_QUIRK_STRICT_DUPLICATE_FILTER)) {
                /* Validate RSSI value against the RSSI threshold once more. */
                if (hdev->discovery.rssi != HCI_RSSI_INVALID &&
                    rssi < hdev->discovery.rssi)
index 5a8ccc491b14440c4f03eb6b752b05353898985a..c560d84676696b4530a9aa77a13076d4b13da6ca 100644 (file)
@@ -989,7 +989,7 @@ static void msft_monitor_device_evt(struct hci_dev *hdev, struct sk_buff *skb)
 
        handle_data = msft_find_handle_data(hdev, ev->monitor_handle, false);
 
-       if (!test_bit(HCI_QUIRK_USE_MSFT_EXT_ADDRESS_FILTER, &hdev->quirks)) {
+       if (!hci_test_quirk(hdev, HCI_QUIRK_USE_MSFT_EXT_ADDRESS_FILTER)) {
                if (!handle_data)
                        return;
                mgmt_handle = handle_data->mgmt_handle;