tree d968f29e599970392f2d0446c4a688d4386eb4b6
parent 83871f8ccdfa8f3edab15d432aa4f3eb82953343
author Tedd Ho-Jeong An <tedd.an@intel.com> 1467129399 -0700
committer Marcel Holtmann <marcel@holtmann.org> 1467973257 +0200

Bluetooth: Replace constant hw_variant from Intel Bluetooth firmware filename

The format of Intel Bluetooth firmware filename for bootloader product
is ibt-<hw_variant>-<device_revision_id>.sfi

Currently the driver uses a constant value 11 (0x0b) for hw_variant
to support LnP/SfP product. But new product like WsP product has
a different value such as 12 (0x0c).

To support the multiple products, this patch replaces the constant
value of hw_variant to the actual hw_variant value read from
the device.

Signed-off-by: Tedd Ho-Jeong An <tedd.an@intel.com>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
