Commit e2dfb94f authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge tag 'for-net-next-2021-12-29' of... 

Merge tag 'for-net-next-2021-12-29' of git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next

Luiz Augusto von Dentz says:

====================
bluetooth-next pull request for net-next:

 - Add support for Foxconn MT7922A
 - Add support for Realtek RTL8852AE
 - Rework HCI event handling to use skb_pull_data

* tag 'for-net-next-2021-12-29' of git://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next: (62 commits)
  Bluetooth: MGMT: Fix spelling mistake "simultanous" -> "simultaneous"
  Bluetooth: vhci: Set HCI_QUIRK_VALID_LE_STATES
  Bluetooth: MGMT: Fix LE simultaneous roles UUID if not supported
  Bluetooth: hci_sync: Add check simultaneous roles support
  Bluetooth: hci_sync: Wait for proper events when connecting LE
  Bluetooth: hci_sync: Add support for waiting specific LE subevents
  Bluetooth: hci_sync: Add hci_le_create_conn_sync
  Bluetooth: hci_event: Use skb_pull_data when processing inquiry results
  Bluetooth: hci_sync: Push sync command cancellation to workqueue
  Bluetooth: hci_qca: Stop IBS timer during BT OFF
  Bluetooth: btusb: Add support for Foxconn MT7922A
  Bluetooth: btintel: Add missing quirks and msft ext for legacy bootloader
  Bluetooth: btusb: Add two more Bluetooth parts for WCN6855
  Bluetooth: L2CAP: Fix using wrong mode
  Bluetooth: hci_sync: Fix not always pausing advertising when necessary
  Bluetooth: mgmt: Make use of mgmt_send_event_skb in MGMT_EV_DEVICE_CONNECTED
  Bluetooth: mgmt: Make use of mgmt_send_event_skb in MGMT_EV_DEVICE_FOUND
  Bluetooth: mgmt: Introduce mgmt_alloc_skb and mgmt_send_event_skb
  Bluetooth: btusb: Return error code when getting patch status failed
  Bluetooth: btusb: Handle download_firmware failure cases
  ...
====================

Link: https://lore.kernel.org/r/20211229211258.2290966-1-luiz.dentz@gmail.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents cfcad56b 5d1dd2e5

drivers/bluetooth/btbcm.c

+39 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 


#include <linux/module.h>

#include <linux/firmware.h>

#include <linux/dmi.h>

#include <asm/unaligned.h>



#include <net/bluetooth/bluetooth.h>
@@ -343,6 +344,40 @@ static struct sk_buff *btbcm_read_usb_product(struct hci_dev *hdev) 
	return skb;

}



static const struct dmi_system_id disable_broken_read_transmit_power[] = {

	{

		 .matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),

			DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro16,1"),

		},

	},

	{

		 .matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),

			DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro16,2"),

		},

	},

	{

		 .matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),

			DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro16,4"),

		},

	},

	{

		 .matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),

			DMI_MATCH(DMI_PRODUCT_NAME, "iMac20,1"),

		},

	},

	{

		 .matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "Apple Inc."),

			DMI_MATCH(DMI_PRODUCT_NAME, "iMac20,2"),

		},

	},

	{ }

};



static int btbcm_read_info(struct hci_dev *hdev)

{

	struct sk_buff *skb;
@@ -363,6 +398,10 @@ static int btbcm_read_info(struct hci_dev *hdev) 
	bt_dev_info(hdev, "BCM: features 0x%2.2x", skb->data[1]);

	kfree_skb(skb);



	/* 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);



	return 0;

}

drivers/bluetooth/btintel.c

+22 −4
Original line number Diff line number Diff line
@@ -2498,10 +2498,14 @@ static int btintel_setup_combined(struct hci_dev *hdev) 
	case 0x12:      /* ThP */

	case 0x13:      /* HrP */

	case 0x14:      /* CcP */

		/* Some legacy bootloader devices from JfP supports both old

		 * and TLV based HCI_Intel_Read_Version command. But we don't

		 * want to use the TLV based setup routines for those legacy

		 * bootloader device.

		/* Some legacy bootloader devices starting from JfP,

		 * the operational firmware supports both old and TLV based

		 * HCI_Intel_Read_Version command based on the command

		 * parameter.

		 *

		 * For upgrading firmware case, the TLV based version cannot

		 * be used because the firmware filename for legacy bootloader

		 * is based on the old format.

		 *

		 * Also, it is not easy to convert TLV based version from the

		 * legacy version format.
@@ -2513,6 +2517,20 @@ static int btintel_setup_combined(struct hci_dev *hdev) 
		err = btintel_read_version(hdev, &ver);

		if (err)

			return err;



		/* Apply the device specific HCI quirks

		 *

		 * All Legacy bootloader devices support WBS

		 */

		set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);



		/* Valid LE States quirk for JfP/ThP familiy */

		if (ver.hw_variant == 0x11 || ver.hw_variant == 0x12)

			set_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks);



		/* Setup MSFT Extension support */

		btintel_set_msft_opcode(hdev, ver.hw_variant);



		err = btintel_bootloader_setup(hdev, &ver);

		break;

	case 0x17:

drivers/bluetooth/btmtk.c

+1 −0
Original line number Diff line number Diff line
@@ -121,6 +121,7 @@ int btmtk_setup_firmware_79xx(struct hci_dev *hdev, const char *fwname, 
				} else {

					bt_dev_err(hdev, "Failed wmt patch dwnld status (%d)",

						   status);

					err = -EIO;

					goto err_release_fw;

				}

			}

drivers/bluetooth/btmtksdio.c

+43 −6
Original line number Diff line number Diff line
@@ -98,6 +98,8 @@ MODULE_DEVICE_TABLE(sdio, btmtksdio_table); 
#define MTK_SDIO_BLOCK_SIZE	256



#define BTMTKSDIO_TX_WAIT_VND_EVT	1

#define BTMTKSDIO_HW_TX_READY		2

#define BTMTKSDIO_FUNC_ENABLED		3



struct mtkbtsdio_hdr {

	__le16	len;
@@ -113,7 +115,6 @@ struct btmtksdio_dev { 
	struct work_struct txrx_work;

	unsigned long tx_state;

	struct sk_buff_head txq;

	bool hw_tx_ready;



	struct sk_buff *evt_skb;
@@ -254,7 +255,7 @@ static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev, 
	sdio_hdr->reserved = cpu_to_le16(0);

	sdio_hdr->bt_type = hci_skb_pkt_type(skb);



	bdev->hw_tx_ready = false;

	clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);

	err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data,

			   round_up(skb->len, MTK_SDIO_BLOCK_SIZE));

	if (err < 0)
@@ -324,8 +325,29 @@ static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb) 
	return err;

}



static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb)

{

	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);

	u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle);



	switch (handle) {

	case 0xfc6f:

		/* Firmware dump from device: when the firmware hangs, the

		 * device can no longer suspend and thus disable auto-suspend.

		 */

		pm_runtime_forbid(bdev->dev);

		fallthrough;

	case 0x05ff:

	case 0x05fe:

		/* Firmware debug logging */

		return hci_recv_diag(hdev, skb);

	}



	return hci_recv_frame(hdev, skb);

}



static const struct h4_recv_pkt mtk_recv_pkts[] = {

	{ H4_RECV_ACL,      .recv = hci_recv_frame },

	{ H4_RECV_ACL,      .recv = btmtksdio_recv_acl },

	{ H4_RECV_SCO,      .recv = hci_recv_frame },

	{ H4_RECV_EVENT,    .recv = btmtksdio_recv_event },

};
@@ -463,11 +485,12 @@ static void btmtksdio_txrx_work(struct work_struct *work) 
			bt_dev_dbg(bdev->hdev, "Get fw own back");



		if (int_status & TX_EMPTY)

			bdev->hw_tx_ready = true;

			set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);



		else if (unlikely(int_status & TX_FIFO_OVERFLOW))

			bt_dev_warn(bdev->hdev, "Tx fifo overflow");



		if (bdev->hw_tx_ready) {

		if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) {

			skb = skb_dequeue(&bdev->txq);

			if (skb) {

				err = btmtksdio_tx_packet(bdev, skb);
@@ -517,6 +540,8 @@ static int btmtksdio_open(struct hci_dev *hdev) 
	if (err < 0)

		goto err_release_host;



	set_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);



	/* Get ownership from the device */

	sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);

	if (err < 0)
@@ -618,6 +643,7 @@ static int btmtksdio_close(struct hci_dev *hdev) 
	if (err < 0)

		bt_dev_err(bdev->hdev, "Cannot return ownership to device");



	clear_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);

	sdio_disable_func(bdev->func);



	sdio_release_host(bdev->func);
@@ -765,6 +791,9 @@ static int mt79xx_setup(struct hci_dev *hdev, const char *fwname) 
		return err;

	}



	hci_set_msft_opcode(hdev, 0xFD30);

	hci_set_aosp_capable(hdev);



	return err;

}
@@ -811,7 +840,7 @@ static int btmtksdio_setup(struct hci_dev *hdev) 
	u32 fw_version = 0;



	calltime = ktime_get();

	bdev->hw_tx_ready = true;

	set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);



	switch (bdev->data->chipid) {

	case 0x7921:
@@ -1036,6 +1065,11 @@ static int btmtksdio_runtime_suspend(struct device *dev) 
	if (!bdev)

		return 0;



	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))

		return 0;



	sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);



	sdio_claim_host(bdev->func);



	sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err);
@@ -1063,6 +1097,9 @@ static int btmtksdio_runtime_resume(struct device *dev) 
	if (!bdev)

		return 0;



	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))

		return 0;



	sdio_claim_host(bdev->func);



	sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);

drivers/bluetooth/btusb.c

+175 −9
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <linux/of_irq.h>

#include <linux/suspend.h>

#include <linux/gpio/consumer.h>

#include <linux/debugfs.h>

#include <asm/unaligned.h>



#include <net/bluetooth/bluetooth.h>
@@ -31,7 +32,6 @@ 
static bool disable_scofix;

static bool force_scofix;

static bool enable_autosuspend = IS_ENABLED(CONFIG_BT_HCIBTUSB_AUTOSUSPEND);



static bool reset = true;



static struct usb_driver btusb_driver;
@@ -296,6 +296,21 @@ static const struct usb_device_id blacklist_table[] = { 
	{ USB_DEVICE(0x0cf3, 0xe600), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },

	{ USB_DEVICE(0x0489, 0xe0cc), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },

	{ USB_DEVICE(0x0489, 0xe0d6), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },

	{ USB_DEVICE(0x0489, 0xe0e3), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },

	{ USB_DEVICE(0x10ab, 0x9309), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },

	{ USB_DEVICE(0x10ab, 0x9409), .driver_info = BTUSB_QCA_WCN6855 |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },



	/* Broadcom BCM2035 */

	{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
@@ -385,6 +400,8 @@ static const struct usb_device_id blacklist_table[] = { 
	/* Realtek 8852AE Bluetooth devices */

	{ USB_DEVICE(0x0bda, 0xc852), .driver_info = BTUSB_REALTEK |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0bda, 0x385a), .driver_info = BTUSB_REALTEK |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x0bda, 0x4852), .driver_info = BTUSB_REALTEK |

						     BTUSB_WIDEBAND_SPEECH },

	{ USB_DEVICE(0x04c5, 0x165c), .driver_info = BTUSB_REALTEK |
@@ -424,6 +441,14 @@ static const struct usb_device_id blacklist_table[] = { 
						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },



	/* MediaTek MT7922A Bluetooth devices */

	{ USB_DEVICE(0x0489, 0xe0d8), .driver_info = BTUSB_MEDIATEK |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },

	{ USB_DEVICE(0x0489, 0xe0d9), .driver_info = BTUSB_MEDIATEK |

						     BTUSB_WIDEBAND_SPEECH |

						     BTUSB_VALID_LE_STATES },



	/* Additional Realtek 8723AE Bluetooth devices */

	{ USB_DEVICE(0x0930, 0x021d), .driver_info = BTUSB_REALTEK },

	{ USB_DEVICE(0x13d3, 0x3394), .driver_info = BTUSB_REALTEK },
@@ -550,8 +575,13 @@ struct btusb_data { 


	unsigned long flags;



	bool poll_sync;

	int intr_interval;

	struct work_struct  work;

	struct work_struct  waker;

	struct delayed_work rx_work;



	struct sk_buff_head acl_q;



	struct usb_anchor deferred;

	struct usb_anchor tx_anchor;
@@ -716,6 +746,16 @@ static inline void btusb_free_frags(struct btusb_data *data) 
	spin_unlock_irqrestore(&data->rxlock, flags);

}



static int btusb_recv_event(struct btusb_data *data, struct sk_buff *skb)

{

	if (data->intr_interval) {

		/* Trigger dequeue immediatelly if an event is received */

		schedule_delayed_work(&data->rx_work, 0);

	}



	return data->recv_event(data->hdev, skb);

}



static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)

{

	struct sk_buff *skb;
@@ -761,7 +801,7 @@ static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count) 


		if (!hci_skb_expect(skb)) {

			/* Complete frame */

			data->recv_event(data->hdev, skb);

			btusb_recv_event(data, skb);

			skb = NULL;

		}

	}
@@ -772,6 +812,20 @@ static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count) 
	return err;

}



static int btusb_recv_acl(struct btusb_data *data, struct sk_buff *skb)

{

	/* Only queue ACL packet if intr_interval is set as it means

	 * force_poll_sync has been enabled.

	 */

	if (!data->intr_interval)

		return data->recv_acl(data->hdev, skb);



	skb_queue_tail(&data->acl_q, skb);

	schedule_delayed_work(&data->rx_work, data->intr_interval);



	return 0;

}



static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)

{

	struct sk_buff *skb;
@@ -819,7 +873,7 @@ static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count) 


		if (!hci_skb_expect(skb)) {

			/* Complete frame */

			data->recv_acl(data->hdev, skb);

			btusb_recv_acl(data, skb);

			skb = NULL;

		}

	}
@@ -925,6 +979,8 @@ static void btusb_intr_complete(struct urb *urb) 
		if (err != -EPERM && err != -ENODEV)

			bt_dev_err(hdev, "urb %p failed to resubmit (%d)",

				   urb, -err);

		if (err != -EPERM)

			hci_cmd_sync_cancel(hdev, -err);

		usb_unanchor_urb(urb);

	}

}
@@ -968,9 +1024,33 @@ static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags) 
		if (err != -EPERM && err != -ENODEV)

			bt_dev_err(hdev, "urb %p submission failed (%d)",

				   urb, -err);

		if (err != -EPERM)

			hci_cmd_sync_cancel(hdev, -err);

		usb_unanchor_urb(urb);

	}



	/* Only initialize intr_interval if URB poll sync is enabled */

	if (!data->poll_sync)

		goto done;



	/* The units are frames (milliseconds) for full and low speed devices,

	 * and microframes (1/8 millisecond) for highspeed and SuperSpeed

	 * devices.

	 *

	 * This is done once on open/resume so it shouldn't change even if

	 * force_poll_sync changes.

	 */

	switch (urb->dev->speed) {

	case USB_SPEED_SUPER_PLUS:

	case USB_SPEED_SUPER:	/* units are 125us */

		data->intr_interval = usecs_to_jiffies(urb->interval * 125);

		break;

	default:

		data->intr_interval = msecs_to_jiffies(urb->interval);

		break;

	}



done:

	usb_free_urb(urb);



	return err;
@@ -1323,10 +1403,13 @@ static void btusb_tx_complete(struct urb *urb) 
	if (!test_bit(HCI_RUNNING, &hdev->flags))

		goto done;



	if (!urb->status)

	if (!urb->status) {

		hdev->stat.byte_tx += urb->transfer_buffer_length;

	else

	} else {

		if (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT)

			hci_cmd_sync_cancel(hdev, -urb->status);

		hdev->stat.err_tx++;

	}



done:

	spin_lock_irqsave(&data->txlock, flags);
@@ -1430,9 +1513,12 @@ static int btusb_close(struct hci_dev *hdev) 


	BT_DBG("%s", hdev->name);



	cancel_delayed_work(&data->rx_work);

	cancel_work_sync(&data->work);

	cancel_work_sync(&data->waker);



	skb_queue_purge(&data->acl_q);



	clear_bit(BTUSB_ISOC_RUNNING, &data->flags);

	clear_bit(BTUSB_BULK_RUNNING, &data->flags);

	clear_bit(BTUSB_INTR_RUNNING, &data->flags);
@@ -1464,6 +1550,10 @@ static int btusb_flush(struct hci_dev *hdev) 


	BT_DBG("%s", hdev->name);



	cancel_delayed_work(&data->rx_work);



	skb_queue_purge(&data->acl_q);



	usb_kill_anchored_urbs(&data->tx_anchor);

	btusb_free_frags(data);
@@ -1827,6 +1917,17 @@ static void btusb_waker(struct work_struct *work) 
	usb_autopm_put_interface(data->intf);

}



static void btusb_rx_work(struct work_struct *work)

{

	struct btusb_data *data = container_of(work, struct btusb_data,

					       rx_work.work);

	struct sk_buff *skb;



	/* Dequeue ACL data received during the interval */

	while ((skb = skb_dequeue(&data->acl_q)))

		data->recv_acl(data->hdev, skb);

}



static int btusb_setup_bcm92035(struct hci_dev *hdev)

{

	struct sk_buff *skb;
@@ -2546,6 +2647,10 @@ static int btusb_mtk_setup(struct hci_dev *hdev) 
			 dev_id & 0xffff, (fw_version & 0xff) + 1);

		err = btmtk_setup_firmware_79xx(hdev, fw_bin_name,

						btusb_mtk_hci_wmt_sync);

		if (err < 0) {

			bt_dev_err(hdev, "Failed to set up firmware (%d)", err);

			return err;

		}



		/* It's Device EndPoint Reset Option Register */

		btusb_mtk_uhw_reg_write(data, MTK_EP_RST_OPT, MTK_EP_RST_IN_OUT_OPT);
@@ -2884,7 +2989,8 @@ struct qca_version { 
	__le32	rom_version;

	__le32	patch_version;

	__le32	ram_version;

	__le16	board_id;

	__u8	chip_id;

	__u8	platform_id;

	__le16	flag;

	__u8	reserved[4];

} __packed;
@@ -3073,7 +3179,17 @@ static void btusb_generate_qca_nvm_name(char *fwname, size_t max_size, 
	u16 flag = le16_to_cpu(ver->flag);



	if (((flag >> 8) & 0xff) == QCA_FLAG_MULTI_NVM) {

		u16 board_id = le16_to_cpu(ver->board_id);

		/* The board_id should be split into two bytes

		 * The 1st byte is chip ID, and the 2nd byte is platform ID

		 * For example, board ID 0x010A, 0x01 is platform ID. 0x0A is chip ID

		 * we have several platforms, and platform IDs are continuously added

		 * Platform ID:

		 * 0x00 is for Mobile

		 * 0x01 is for X86

		 * 0x02 is for Automotive

		 * 0x03 is for Consumer electronic

		 */

		u16 board_id = (ver->chip_id << 8) + ver->platform_id;

		const char *variant;



		switch (le32_to_cpu(ver->ram_version)) {
@@ -3373,6 +3489,49 @@ static int btusb_shutdown_qca(struct hci_dev *hdev) 
	return 0;

}



static ssize_t force_poll_sync_read(struct file *file, char __user *user_buf,

				    size_t count, loff_t *ppos)

{

	struct btusb_data *data = file->private_data;

	char buf[3];



	buf[0] = data->poll_sync ? 'Y' : 'N';

	buf[1] = '\n';

	buf[2] = '\0';

	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);

}



static ssize_t force_poll_sync_write(struct file *file,

				     const char __user *user_buf,

				     size_t count, loff_t *ppos)

{

	struct btusb_data *data = file->private_data;

	bool enable;

	int err;



	err = kstrtobool_from_user(user_buf, count, &enable);

	if (err)

		return err;



	/* Only allow changes while the adapter is down */

	if (test_bit(HCI_UP, &data->hdev->flags))

		return -EPERM;



	if (data->poll_sync == enable)

		return -EALREADY;



	data->poll_sync = enable;



	return count;

}



static const struct file_operations force_poll_sync_fops = {

	.open		= simple_open,

	.read		= force_poll_sync_read,

	.write		= force_poll_sync_write,

	.llseek		= default_llseek,

};



static int btusb_probe(struct usb_interface *intf,

		       const struct usb_device_id *id)

{
@@ -3456,6 +3615,10 @@ static int btusb_probe(struct usb_interface *intf, 


	INIT_WORK(&data->work, btusb_work);

	INIT_WORK(&data->waker, btusb_waker);

	INIT_DELAYED_WORK(&data->rx_work, btusb_rx_work);



	skb_queue_head_init(&data->acl_q);



	init_usb_anchor(&data->deferred);

	init_usb_anchor(&data->tx_anchor);

	spin_lock_init(&data->txlock);
@@ -3721,6 +3884,9 @@ static int btusb_probe(struct usb_interface *intf, 


	usb_set_intfdata(intf, data);



	debugfs_create_file("force_poll_sync", 0644, hdev->debugfs, data,

			    &force_poll_sync_fops);



	return 0;



out_free_dev: