735ff43197
Modifying the interface used to lower the tx power level for meeting SAR requirements based on recommendation from the nexus hardware team. The previous interface passed in a single power value in dBm for meeting SAR requirements. However, the SAR requirements are more complex than that. Based on the connection mode (802.11 a,b,g,n,ac) and the number of streams that are active (MIMO), the SAR power levels are very different. Using the previous interface would mean that we will have to use the lowest power level among all the connection modes to meet the SAR requirements. This would however result in us lowering the power much more than needed (~2 dBm) for many connection modes. Instead, we're switching to a more generic interface where the framework informs the wifi chip that we're entering a special tx power mode scenario (today, there is only 1 for voice call). The chip can then lookup the extensive table of power levels for different connection modes which are pre-populated by the OEM's in the BDF file to set the power level (depending on the scenario framework sends and the active connection mode). Bug: 62437848 Test: Manual tests Change-Id: I5ee3f0d2c130958dbeb352e3b5ad9407f432624f
217 lines
9.6 KiB
C++
217 lines
9.6 KiB
C++
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef WIFI_CHIP_H_
|
|
#define WIFI_CHIP_H_
|
|
|
|
#include <map>
|
|
|
|
#include <android-base/macros.h>
|
|
#include <android/hardware/wifi/1.1/IWifiChip.h>
|
|
|
|
#include "hidl_callback_util.h"
|
|
#include "wifi_ap_iface.h"
|
|
#include "wifi_legacy_hal.h"
|
|
#include "wifi_mode_controller.h"
|
|
#include "wifi_nan_iface.h"
|
|
#include "wifi_p2p_iface.h"
|
|
#include "wifi_rtt_controller.h"
|
|
#include "wifi_sta_iface.h"
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace wifi {
|
|
namespace V1_1 {
|
|
namespace implementation {
|
|
using namespace android::hardware::wifi::V1_0;
|
|
|
|
/**
|
|
* HIDL interface object used to control a Wifi HAL chip instance.
|
|
* Since there is only a single chip instance used today, there is no
|
|
* identifying handle information stored here.
|
|
*/
|
|
class WifiChip : public V1_1::IWifiChip {
|
|
public:
|
|
WifiChip(
|
|
ChipId chip_id,
|
|
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
|
|
const std::weak_ptr<mode_controller::WifiModeController> mode_controller);
|
|
// HIDL does not provide a built-in mechanism to let the server invalidate
|
|
// a HIDL interface object after creation. If any client process holds onto
|
|
// a reference to the object in their context, any method calls on that
|
|
// reference will continue to be directed to the server.
|
|
//
|
|
// However Wifi HAL needs to control the lifetime of these objects. So, add
|
|
// a public |invalidate| method to |WifiChip| and it's child objects. This
|
|
// will be used to mark an object invalid when either:
|
|
// a) Wifi HAL is stopped, or
|
|
// b) Wifi Chip is reconfigured.
|
|
//
|
|
// All HIDL method implementations should check if the object is still marked
|
|
// valid before processing them.
|
|
void invalidate();
|
|
bool isValid();
|
|
std::set<sp<IWifiChipEventCallback>> getEventCallbacks();
|
|
|
|
// HIDL methods exposed.
|
|
Return<void> getId(getId_cb hidl_status_cb) override;
|
|
Return<void> registerEventCallback(
|
|
const sp<IWifiChipEventCallback>& event_callback,
|
|
registerEventCallback_cb hidl_status_cb) override;
|
|
Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
|
|
Return<void> getAvailableModes(getAvailableModes_cb hidl_status_cb) override;
|
|
Return<void> configureChip(ChipModeId mode_id,
|
|
configureChip_cb hidl_status_cb) override;
|
|
Return<void> getMode(getMode_cb hidl_status_cb) override;
|
|
Return<void> requestChipDebugInfo(
|
|
requestChipDebugInfo_cb hidl_status_cb) override;
|
|
Return<void> requestDriverDebugDump(
|
|
requestDriverDebugDump_cb hidl_status_cb) override;
|
|
Return<void> requestFirmwareDebugDump(
|
|
requestFirmwareDebugDump_cb hidl_status_cb) override;
|
|
Return<void> createApIface(createApIface_cb hidl_status_cb) override;
|
|
Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override;
|
|
Return<void> getApIface(const hidl_string& ifname,
|
|
getApIface_cb hidl_status_cb) override;
|
|
Return<void> removeApIface(const hidl_string& ifname,
|
|
removeApIface_cb hidl_status_cb) override;
|
|
Return<void> createNanIface(createNanIface_cb hidl_status_cb) override;
|
|
Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override;
|
|
Return<void> getNanIface(const hidl_string& ifname,
|
|
getNanIface_cb hidl_status_cb) override;
|
|
Return<void> removeNanIface(const hidl_string& ifname,
|
|
removeNanIface_cb hidl_status_cb) override;
|
|
Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override;
|
|
Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override;
|
|
Return<void> getP2pIface(const hidl_string& ifname,
|
|
getP2pIface_cb hidl_status_cb) override;
|
|
Return<void> removeP2pIface(const hidl_string& ifname,
|
|
removeP2pIface_cb hidl_status_cb) override;
|
|
Return<void> createStaIface(createStaIface_cb hidl_status_cb) override;
|
|
Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override;
|
|
Return<void> getStaIface(const hidl_string& ifname,
|
|
getStaIface_cb hidl_status_cb) override;
|
|
Return<void> removeStaIface(const hidl_string& ifname,
|
|
removeStaIface_cb hidl_status_cb) override;
|
|
Return<void> createRttController(
|
|
const sp<IWifiIface>& bound_iface,
|
|
createRttController_cb hidl_status_cb) override;
|
|
Return<void> getDebugRingBuffersStatus(
|
|
getDebugRingBuffersStatus_cb hidl_status_cb) override;
|
|
Return<void> startLoggingToDebugRingBuffer(
|
|
const hidl_string& ring_name,
|
|
WifiDebugRingBufferVerboseLevel verbose_level,
|
|
uint32_t max_interval_in_sec,
|
|
uint32_t min_data_size_in_bytes,
|
|
startLoggingToDebugRingBuffer_cb hidl_status_cb) override;
|
|
Return<void> forceDumpToDebugRingBuffer(
|
|
const hidl_string& ring_name,
|
|
forceDumpToDebugRingBuffer_cb hidl_status_cb) override;
|
|
Return<void> stopLoggingToDebugRingBuffer(
|
|
stopLoggingToDebugRingBuffer_cb hidl_status_cb) override;
|
|
Return<void> getDebugHostWakeReasonStats(
|
|
getDebugHostWakeReasonStats_cb hidl_status_cb) override;
|
|
Return<void> enableDebugErrorAlerts(
|
|
bool enable, enableDebugErrorAlerts_cb hidl_status_cb) override;
|
|
Return<void> selectTxPowerScenario(
|
|
TxPowerScenario scenario,
|
|
selectTxPowerScenario_cb hidl_status_cb) override;
|
|
Return<void> resetTxPowerScenario(
|
|
resetTxPowerScenario_cb hidl_status_cb) override;
|
|
|
|
private:
|
|
void invalidateAndRemoveAllIfaces();
|
|
|
|
// Corresponding worker functions for the HIDL methods.
|
|
std::pair<WifiStatus, ChipId> getIdInternal();
|
|
WifiStatus registerEventCallbackInternal(
|
|
const sp<IWifiChipEventCallback>& event_callback);
|
|
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
|
|
std::pair<WifiStatus, std::vector<ChipMode>> getAvailableModesInternal();
|
|
WifiStatus configureChipInternal(ChipModeId mode_id);
|
|
std::pair<WifiStatus, uint32_t> getModeInternal();
|
|
std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
|
|
requestChipDebugInfoInternal();
|
|
std::pair<WifiStatus, std::vector<uint8_t>> requestDriverDebugDumpInternal();
|
|
std::pair<WifiStatus, std::vector<uint8_t>>
|
|
requestFirmwareDebugDumpInternal();
|
|
std::pair<WifiStatus, sp<IWifiApIface>> createApIfaceInternal();
|
|
std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal();
|
|
std::pair<WifiStatus, sp<IWifiApIface>> getApIfaceInternal(
|
|
const std::string& ifname);
|
|
WifiStatus removeApIfaceInternal(const std::string& ifname);
|
|
std::pair<WifiStatus, sp<IWifiNanIface>> createNanIfaceInternal();
|
|
std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal();
|
|
std::pair<WifiStatus, sp<IWifiNanIface>> getNanIfaceInternal(
|
|
const std::string& ifname);
|
|
WifiStatus removeNanIfaceInternal(const std::string& ifname);
|
|
std::pair<WifiStatus, sp<IWifiP2pIface>> createP2pIfaceInternal();
|
|
std::pair<WifiStatus, std::vector<hidl_string>> getP2pIfaceNamesInternal();
|
|
std::pair<WifiStatus, sp<IWifiP2pIface>> getP2pIfaceInternal(
|
|
const std::string& ifname);
|
|
WifiStatus removeP2pIfaceInternal(const std::string& ifname);
|
|
std::pair<WifiStatus, sp<IWifiStaIface>> createStaIfaceInternal();
|
|
std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
|
|
std::pair<WifiStatus, sp<IWifiStaIface>> getStaIfaceInternal(
|
|
const std::string& ifname);
|
|
WifiStatus removeStaIfaceInternal(const std::string& ifname);
|
|
std::pair<WifiStatus, sp<IWifiRttController>> createRttControllerInternal(
|
|
const sp<IWifiIface>& bound_iface);
|
|
std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
|
|
getDebugRingBuffersStatusInternal();
|
|
WifiStatus startLoggingToDebugRingBufferInternal(
|
|
const hidl_string& ring_name,
|
|
WifiDebugRingBufferVerboseLevel verbose_level,
|
|
uint32_t max_interval_in_sec,
|
|
uint32_t min_data_size_in_bytes);
|
|
WifiStatus forceDumpToDebugRingBufferInternal(const hidl_string& ring_name);
|
|
WifiStatus stopLoggingToDebugRingBufferInternal();
|
|
std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
|
|
getDebugHostWakeReasonStatsInternal();
|
|
WifiStatus enableDebugErrorAlertsInternal(bool enable);
|
|
WifiStatus selectTxPowerScenarioInternal(TxPowerScenario scenario);
|
|
WifiStatus resetTxPowerScenarioInternal();
|
|
|
|
WifiStatus handleChipConfiguration(ChipModeId mode_id);
|
|
WifiStatus registerDebugRingBufferCallback();
|
|
|
|
ChipId chip_id_;
|
|
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
|
|
std::weak_ptr<mode_controller::WifiModeController> mode_controller_;
|
|
sp<WifiApIface> ap_iface_;
|
|
sp<WifiNanIface> nan_iface_;
|
|
sp<WifiP2pIface> p2p_iface_;
|
|
sp<WifiStaIface> sta_iface_;
|
|
std::vector<sp<WifiRttController>> rtt_controllers_;
|
|
bool is_valid_;
|
|
uint32_t current_mode_id_;
|
|
// The legacy ring buffer callback API has only a global callback
|
|
// registration mechanism. Use this to check if we have already
|
|
// registered a callback.
|
|
bool debug_ring_buffer_cb_registered_;
|
|
hidl_callback_util::HidlCallbackHandler<IWifiChipEventCallback>
|
|
event_cb_handler_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(WifiChip);
|
|
};
|
|
|
|
} // namespace implementation
|
|
} // namespace V1_1
|
|
} // namespace wifi
|
|
} // namespace hardware
|
|
} // namespace android
|
|
|
|
#endif // WIFI_CHIP_H_
|