diff options
Diffstat (limited to 'wifi/1.6/default/wifi_chip.h')
| -rw-r--r-- | wifi/1.6/default/wifi_chip.h | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/wifi/1.6/default/wifi_chip.h b/wifi/1.6/default/wifi_chip.h new file mode 100644 index 0000000000..8a068985d1 --- /dev/null +++ b/wifi/1.6/default/wifi_chip.h @@ -0,0 +1,294 @@ +/* + * 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 <list> +#include <map> +#include <mutex> + +#include <android-base/macros.h> +#include <android/hardware/wifi/1.4/IWifiRttController.h> +#include <android/hardware/wifi/1.5/IWifiChip.h> + +#include "hidl_callback_util.h" +#include "ringbuffer.h" +#include "wifi_ap_iface.h" +#include "wifi_feature_flags.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_6 { +namespace implementation { +using namespace android::hardware::wifi::V1_0; +using V1_5::WifiBand; +using V1_5::WifiUsableChannel; + +/** + * 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_5::IWifiChip { + public: + WifiChip(ChipId chip_id, bool is_primary, + const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal, + const std::weak_ptr<mode_controller::WifiModeController> mode_controller, + const std::shared_ptr<iface_util::WifiIfaceUtil> iface_util, + const std::weak_ptr<feature_flags::WifiFeatureFlags> feature_flags, + const std::function<void(const std::string&)>& subsystemCallbackHandler); + // 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<V1_4::IWifiChipEventCallback>> getEventCallbacks(); + + // HIDL methods exposed. + Return<void> getId(getId_cb hidl_status_cb) override; + // Deprecated support for this callback + Return<void> registerEventCallback(const sp<V1_0::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> createBridgedApIface(createBridgedApIface_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> removeIfaceInstanceFromBridgedApIface( + const hidl_string& brIfaceName, const hidl_string& ifaceInstanceName, + removeIfaceInstanceFromBridgedApIface_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> flushRingBufferToFile(flushRingBufferToFile_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(V1_1::IWifiChip::TxPowerScenario scenario, + selectTxPowerScenario_cb hidl_status_cb) override; + Return<void> resetTxPowerScenario(resetTxPowerScenario_cb hidl_status_cb) override; + Return<void> setLatencyMode(LatencyMode mode, setLatencyMode_cb hidl_status_cb) override; + Return<void> registerEventCallback_1_2(const sp<V1_2::IWifiChipEventCallback>& event_callback, + registerEventCallback_1_2_cb hidl_status_cb) override; + Return<void> selectTxPowerScenario_1_2(TxPowerScenario scenario, + selectTxPowerScenario_cb hidl_status_cb) override; + Return<void> getCapabilities_1_3(getCapabilities_cb hidl_status_cb) override; + Return<void> getCapabilities_1_5(getCapabilities_1_5_cb hidl_status_cb) override; + Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override; + Return<void> createRttController_1_4(const sp<IWifiIface>& bound_iface, + createRttController_1_4_cb hidl_status_cb) override; + Return<void> registerEventCallback_1_4(const sp<V1_4::IWifiChipEventCallback>& event_callback, + registerEventCallback_1_4_cb hidl_status_cb) override; + Return<void> setMultiStaPrimaryConnection( + const hidl_string& ifname, setMultiStaPrimaryConnection_cb hidl_status_cb) override; + Return<void> setMultiStaUseCase(MultiStaUseCase use_case, + setMultiStaUseCase_cb hidl_status_cb) override; + Return<void> setCoexUnsafeChannels(const hidl_vec<CoexUnsafeChannel>& unsafe_channels, + hidl_bitfield<IfaceType> restrictions, + setCoexUnsafeChannels_cb hidl_status_cb) override; + Return<void> setCountryCode(const hidl_array<int8_t, 2>& code, + setCountryCode_cb _hidl_cb) override; + Return<void> getUsableChannels(WifiBand band, hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask, + hidl_bitfield<UsableChannelFilter> filterMask, + getUsableChannels_cb _hidl_cb) override; + Return<void> triggerSubsystemRestart(triggerSubsystemRestart_cb hidl_status_cb) override; + + private: + void invalidateAndRemoveAllIfaces(); + // When a STA iface is removed any dependent NAN-ifaces/RTT-controllers are + // invalidated & removed. + void invalidateAndRemoveDependencies(const std::string& removed_iface_name); + + // Corresponding worker functions for the HIDL methods. + std::pair<WifiStatus, ChipId> getIdInternal(); + // Deprecated support for this callback + WifiStatus registerEventCallbackInternal( + const sp<V1_0::IWifiChipEventCallback>& event_callback); + std::pair<WifiStatus, uint32_t> getCapabilitiesInternal(); + std::pair<WifiStatus, std::vector<ChipMode>> getAvailableModesInternal(); + WifiStatus configureChipInternal(std::unique_lock<std::recursive_mutex>* lock, + 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(); + sp<WifiApIface> newWifiApIface(std::string& ifname); + WifiStatus createVirtualApInterface(const std::string& apVirtIf); + std::pair<WifiStatus, sp<V1_5::IWifiApIface>> createApIfaceInternal(); + std::pair<WifiStatus, sp<V1_5::IWifiApIface>> createBridgedApIfaceInternal(); + std::pair<WifiStatus, std::vector<hidl_string>> getApIfaceNamesInternal(); + std::pair<WifiStatus, sp<V1_5::IWifiApIface>> getApIfaceInternal(const std::string& ifname); + WifiStatus removeApIfaceInternal(const std::string& ifname); + WifiStatus removeIfaceInstanceFromBridgedApIfaceInternal(const std::string& brIfaceName, + const std::string& ifInstanceName); + std::pair<WifiStatus, sp<V1_4::IWifiNanIface>> createNanIfaceInternal(); + std::pair<WifiStatus, std::vector<hidl_string>> getNanIfaceNamesInternal(); + std::pair<WifiStatus, sp<V1_4::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<V1_5::IWifiStaIface>> createStaIfaceInternal(); + std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal(); + std::pair<WifiStatus, sp<V1_5::IWifiStaIface>> getStaIfaceInternal(const std::string& ifname); + WifiStatus removeStaIfaceInternal(const std::string& ifname); + std::pair<WifiStatus, sp<V1_0::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 flushRingBufferToFileInternal(); + WifiStatus stopLoggingToDebugRingBufferInternal(); + std::pair<WifiStatus, WifiDebugHostWakeReasonStats> getDebugHostWakeReasonStatsInternal(); + WifiStatus enableDebugErrorAlertsInternal(bool enable); + WifiStatus selectTxPowerScenarioInternal(V1_1::IWifiChip::TxPowerScenario scenario); + WifiStatus resetTxPowerScenarioInternal(); + WifiStatus setLatencyModeInternal(LatencyMode mode); + WifiStatus registerEventCallbackInternal_1_2( + const sp<V1_2::IWifiChipEventCallback>& event_callback); + WifiStatus selectTxPowerScenarioInternal_1_2(TxPowerScenario scenario); + std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_3(); + std::pair<WifiStatus, uint32_t> getCapabilitiesInternal_1_5(); + std::pair<WifiStatus, sp<V1_4::IWifiRttController>> createRttControllerInternal_1_4( + const sp<IWifiIface>& bound_iface); + WifiStatus registerEventCallbackInternal_1_4( + const sp<V1_4::IWifiChipEventCallback>& event_callback); + WifiStatus setMultiStaPrimaryConnectionInternal(const std::string& ifname); + WifiStatus setMultiStaUseCaseInternal(MultiStaUseCase use_case); + WifiStatus setCoexUnsafeChannelsInternal(std::vector<CoexUnsafeChannel> unsafe_channels, + uint32_t restrictions); + WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code); + std::pair<WifiStatus, std::vector<WifiUsableChannel>> getUsableChannelsInternal( + WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask); + WifiStatus handleChipConfiguration(std::unique_lock<std::recursive_mutex>* lock, + ChipModeId mode_id); + WifiStatus registerDebugRingBufferCallback(); + WifiStatus registerRadioModeChangeCallback(); + + std::vector<V1_4::IWifiChip::ChipIfaceCombination> getCurrentModeIfaceCombinations(); + std::map<IfaceType, size_t> getCurrentIfaceCombination(); + std::vector<std::map<IfaceType, size_t>> expandIfaceCombinations( + const V1_4::IWifiChip::ChipIfaceCombination& combination); + bool canExpandedIfaceComboSupportIfaceOfTypeWithCurrentIfaces( + const std::map<IfaceType, size_t>& expanded_combo, IfaceType requested_type); + bool canCurrentModeSupportIfaceOfTypeWithCurrentIfaces(IfaceType requested_type); + bool canExpandedIfaceComboSupportIfaceCombo(const std::map<IfaceType, size_t>& expanded_combo, + const std::map<IfaceType, size_t>& req_combo); + bool canCurrentModeSupportIfaceCombo(const std::map<IfaceType, size_t>& req_combo); + bool canCurrentModeSupportIfaceOfType(IfaceType requested_type); + bool isValidModeId(ChipModeId mode_id); + bool isStaApConcurrencyAllowedInCurrentMode(); + bool isDualStaConcurrencyAllowedInCurrentMode(); + uint32_t startIdxOfApIface(); + std::string getFirstActiveWlanIfaceName(); + std::string allocateApOrStaIfaceName(IfaceType type, uint32_t start_idx); + std::string allocateApIfaceName(); + std::vector<std::string> allocateBridgedApInstanceNames(); + std::string allocateStaIfaceName(); + bool writeRingbufferFilesInternal(); + std::string getWlanIfaceNameWithType(IfaceType type, unsigned idx); + void invalidateAndClearBridgedApAll(); + void invalidateAndClearBridgedAp(const std::string& br_name); + bool findUsingNameFromBridgedApInstances(const std::string& name); + WifiStatus triggerSubsystemRestartInternal(); + + ChipId chip_id_; + std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_; + std::weak_ptr<mode_controller::WifiModeController> mode_controller_; + std::shared_ptr<iface_util::WifiIfaceUtil> iface_util_; + std::vector<sp<WifiApIface>> ap_ifaces_; + std::vector<sp<WifiNanIface>> nan_ifaces_; + std::vector<sp<WifiP2pIface>> p2p_ifaces_; + std::vector<sp<WifiStaIface>> sta_ifaces_; + std::vector<sp<WifiRttController>> rtt_controllers_; + std::map<std::string, Ringbuffer> ringbuffer_map_; + bool is_valid_; + // Members pertaining to chip configuration. + uint32_t current_mode_id_; + std::mutex lock_t; + std::vector<V1_4::IWifiChip::ChipMode> modes_; + // 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<V1_4::IWifiChipEventCallback> event_cb_handler_; + + const std::function<void(const std::string&)> subsystemCallbackHandler_; + std::map<std::string, std::vector<std::string>> br_ifaces_ap_instances_; + DISALLOW_COPY_AND_ASSIGN(WifiChip); +}; + +} // namespace implementation +} // namespace V1_6 +} // namespace wifi +} // namespace hardware +} // namespace android + +#endif // WIFI_CHIP_H_ |