tree 98893631c2019a0f74c2554d87d676f259180d72
parent 480e2ee4311f13fc21f6609db26cedcb3cbcaea6
author Rashed Abdel-Tawab <rashed@linux.com> 1513024317 -0800
committer Rashed Abdel-Tawab <rashedabdeltawab@gmail.com> 1515028478 +0000

build: Merge UM platforms into common HALs and disable BSP

While UM platform HALs are interchangable and very much interoperable
between platforms and kernels, some have qualms about commonizing
platforms that Qualcomm hasn't fully commonized themselves yet. Therefore
introduce 2 seperate UM platforms, UM3.18 and UM4.4 (corresponding to
the kernel version used for that "version" of UM) and use msm8996 for
UM3.18 and msm8998 for UM4.4 (sdm845 will probably be UM4.9).

Also disable TARGET_USES_QCOM_BSP on the UM platforms to match Qualcomm
trees as it causes WiFi display not to work and calls for missing headers
and struct elements at build time.

Change-Id: Ia574231243b7d628d35959b474dd28bd37ac4031
