tree a022b50aa7e97eb4ededd290e3869e5dcdf649ba
parent f8c2d907db77aebe42e9f8a4dcc9d76cf3a72005
author Ege Mihmanli <egemih@google.com> 1506705802 +0000
committer chrome-bot <chrome-bot@chromium.org> 1507931128 -0700

Revert "Ensure HuddlyGo camera always configures to dual stream mode."

This reverts commit f8c2d907db77aebe42e9f8a4dcc9d76cf3a72005.

Reason for revert: Stream does not show up when kernel driver is reattached. Will push if and when this issue is resolved.

Original change's description:
> Ensure HuddlyGo camera always configures to dual stream mode.
>
> Huddly's general firmware might not be configured to dual stream mode.
> This checks to make sure Huddly always sends dual stream video.
>
> BUG=none
> TEST=Connect, disconnect camera with different initial streaming modes to CfM.
> Inspect logs to see if huddly-updater configured the stream to the desired value.
>
> Change-Id: I5e9fda746971e6d5980dc3b0349da7555c0487a6
> Reviewed-on: https://chromium-review.googlesource.com/669749
> Commit-Ready: Ege Mihmanli <egemih@google.com>
> Tested-by: Ege Mihmanli <egemih@google.com>
> Reviewed-by: Jiwoong Lee <porce@chromium.org>

Bug: none
Change-Id: I5f722f4a924cfa3853fadb03dd298ce44eec7a92
Reviewed-on: https://chromium-review.googlesource.com/692839
Commit-Ready: Ege Mihmanli <egemih@google.com>
Tested-by: Ege Mihmanli <egemih@google.com>
Reviewed-by: Zhongze Hu <frankhu@google.com>
