The vendor command (0xfc3f) in btusb_shutdown_intel causes an internal
reset with old firmware. After that, upcoming HCI command will hang due
to a controller bug with the first HCI command sent to it.
The workaround is to send HCI Reset command first which will reset the
number of completed commands.
Signed-off-by: Loic Poulain <[email protected]>
---
v2: Send HCI reset from shutdown instead of using HCI_QUIRK_RESET_ON_CLOSE
drivers/bluetooth/btusb.c | 13 +++++++++++++
1 file changed, 13 insertions(+)
diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
index d21f3b4..589f30c 100644
--- a/drivers/bluetooth/btusb.c
+++ b/drivers/bluetooth/btusb.c
@@ -2705,6 +2705,19 @@ static int btusb_shutdown_intel(struct hci_dev *hdev)
}
kfree_skb(skb);
+ /* The 0xfc3f command causes an internal reset with old firmware.
+ * In order to avoid the Bug with the first HCI command, we have
+ * to send a HCI reset which will reset the number of completed
+ * command.
+ */
+ skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
+ if (IS_ERR(skb)) {
+ BT_ERR("%s: Shutdown HCI reset command failed (%ld)",
+ hdev->name, PTR_ERR(skb));
+ return PTR_ERR(skb);
+ }
+ kfree_skb(skb);
+
return 0;
}
--
1.9.1
Hi Tedd,
> The vendor command (0xfc3f) in btusb_shutdown_intel causes an internal
> reset with old firmware. After that, upcoming HCI command will hang due
> to a controller bug with the first HCI command sent to it.
> The workaround is to send HCI Reset command first which will reset the
> number of completed commands.
>
> Signed-off-by: Loic Poulain <[email protected]>
> ---
> v2: Send HCI reset from shutdown instead of using HCI_QUIRK_RESET_ON_CLOSE
> drivers/bluetooth/btusb.c | 13 +++++++++++++
> 1 file changed, 13 insertions(+)
>
> diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
> index d21f3b4..589f30c 100644
> --- a/drivers/bluetooth/btusb.c
> +++ b/drivers/bluetooth/btusb.c
> @@ -2705,6 +2705,19 @@ static int btusb_shutdown_intel(struct hci_dev *hdev)
> }
> kfree_skb(skb);
>
> + /* The 0xfc3f command causes an internal reset with old firmware.
> + * In order to avoid the Bug with the first HCI command, we have
> + * to send a HCI reset which will reset the number of completed
> + * command.
> + */
> + skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
> + if (IS_ERR(skb)) {
> + BT_ERR("%s: Shutdown HCI reset command failed (%ld)",
> + hdev->name, PTR_ERR(skb));
> + return PTR_ERR(skb);
> + }
> + kfree_skb(skb);
> +
please test this change and see if it still has the desired effect. ACK or NACK the patch based on your testing.
Regards
Marcel
Hi Loci,
On Thu, 4 Jun 2015 12:55:32 -0700
"An, Tedd" <[email protected]> wrote:
> Hi Loic
>
> On 6/4/15, 4:59 AM, "Poulain, Loic" <[email protected]> wrote:
>
> >Hi tedd,
> >
> >On 21/05/2015 21:56, Marcel Holtmann wrote:
> >> Hi Tedd,
> >>
> >>> The vendor command (0xfc3f) in btusb_shutdown_intel causes an internal
> >>> reset with old firmware. After that, upcoming HCI command will hang due
> >>> to a controller bug with the first HCI command sent to it.
> >>> The workaround is to send HCI Reset command first which will reset the
> >>> number of completed commands.
> >>>
> >>> Signed-off-by: Loic Poulain <[email protected]>
> >>> ---
> >>> v2: Send HCI reset from shutdown instead of using HCI_QUIRK_RESET_ON_CLOSE
> >>> drivers/bluetooth/btusb.c | 13 +++++++++++++
> >>> 1 file changed, 13 insertions(+)
> >>>
> >>> diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
> >>> index d21f3b4..589f30c 100644
> >>> --- a/drivers/bluetooth/btusb.c
> >>> +++ b/drivers/bluetooth/btusb.c
> >>> @@ -2705,6 +2705,19 @@ static int btusb_shutdown_intel(struct hci_dev *hdev)
> >>> }
> >>> kfree_skb(skb);
> >>>
> >>> + /* The 0xfc3f command causes an internal reset with old firmware.
> >>> + * In order to avoid the Bug with the first HCI command, we have
> >>> + * to send a HCI reset which will reset the number of completed
> >>> + * command.
> >>> + */
> >>> + skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
> >>> + if (IS_ERR(skb)) {
> >>> + BT_ERR("%s: Shutdown HCI reset command failed (%ld)",
> >>> + hdev->name, PTR_ERR(skb));
> >>> + return PTR_ERR(skb);
> >>> + }
> >>> + kfree_skb(skb);
> >>> +
> >> please test this change and see if it still has the desired effect. ACK or NACK the patch based on your testing.
> >>
> >> Regards
> >>
> >> Marcel
> >>
> >
> >Any chance you test this patch?
>
> I missed your patch and just got it. I will run this test and let you know the result.
>
We tested this patch and it re-introduces the LED issue.
The 0xfc3f command turns off the BT LED immediately and BT LED behavior is reset to normal statue (ON)
with HCI_RESET command. So, sending HCI_RESET immediately after 0xfc3f will turn on the LED
back on and it will take another 5 seconds to turn-off again.
However, if HCI_RESET is sent prior to 0xfc3f, it worked ok, if you want to reset the device during
the power off.
> >
> >Regards,
> >Loic
> >
> >--
> >Intel Open Source Technology Center
> >http://oss.intel.com/
> >
Hi Ethan,
> I am helping Tedd to test this patch now, but I have a question about this patch.
>
> For your comment It looks like you want to send HCI RESET command to controller first when BT enabled, then I found below patch also do same thing as your patch. May I know any difference for your patch? Thanks.
> commit dffd30ee9619ccd7153f1861ba0436bbc4400f36
> Author: Tedd Ho-Jeong An <[email protected]>
> Date: Fri Apr 19 09:57:43 2013 -0700
>
> Bluetooth: Add support for Intel Bluetooth device [8087:07dc]
setup is only called for the first open/up to initialize the device.
shutdown is called before each regular HCI close/down to perform vendor
HCI epilog.
The Intel shutdown procedure consist in sending the 0xfc3f command which
seems
to cause an internal reset with old firmwares (LED off with new one).
So, we need to HCI reset the controller before any other command in
order to avoid
the "number of completed commands" issue.
To be sure that this HCI reset will be perform, I just put the HCI reset
after the 0xfc3f
in the shutdown callback.
Since I only have old version, I can only test that the problem is fixed
for me but not that
no regression is caused with the new fw/hw version.
So we need feedback, to know if the expected behavior (LED OFF on
shutdown) is preserved.
Regards,
Loic
--
Intel Open Source Technology Center
http://oss.intel.com/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=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SGkgTG9pYw0KDQoNCg0KT24gNi80LzE1LCA0OjU5IEFNLCAiUG91bGFpbiwgTG9pYyIgPGxvaWMu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Hi tedd,
On 21/05/2015 21:56, Marcel Holtmann wrote:
> Hi Tedd,
>
>> The vendor command (0xfc3f) in btusb_shutdown_intel causes an internal
>> reset with old firmware. After that, upcoming HCI command will hang due
>> to a controller bug with the first HCI command sent to it.
>> The workaround is to send HCI Reset command first which will reset the
>> number of completed commands.
>>
>> Signed-off-by: Loic Poulain <[email protected]>
>> ---
>> v2: Send HCI reset from shutdown instead of using HCI_QUIRK_RESET_ON_CLOSE
>> drivers/bluetooth/btusb.c | 13 +++++++++++++
>> 1 file changed, 13 insertions(+)
>>
>> diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
>> index d21f3b4..589f30c 100644
>> --- a/drivers/bluetooth/btusb.c
>> +++ b/drivers/bluetooth/btusb.c
>> @@ -2705,6 +2705,19 @@ static int btusb_shutdown_intel(struct hci_dev *hdev)
>> }
>> kfree_skb(skb);
>>
>> + /* The 0xfc3f command causes an internal reset with old firmware.
>> + * In order to avoid the Bug with the first HCI command, we have
>> + * to send a HCI reset which will reset the number of completed
>> + * command.
>> + */
>> + skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
>> + if (IS_ERR(skb)) {
>> + BT_ERR("%s: Shutdown HCI reset command failed (%ld)",
>> + hdev->name, PTR_ERR(skb));
>> + return PTR_ERR(skb);
>> + }
>> + kfree_skb(skb);
>> +
> please test this change and see if it still has the desired effect. ACK or NACK the patch based on your testing.
>
> Regards
>
> Marcel
>
Any chance you test this patch?
Regards,
Loic
--
Intel Open Source Technology Center
http://oss.intel.com/