wifi/1.6/default/wifi_chip.h

/*
 * 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_

// HACK: NAN is a macro defined in math.h, which can be included in various
// headers. This wifi HAL uses an enum called NAN, which does not compile when
// the macro is defined. Undefine NAN to work around it.
#undef NAN

#include <list>
#include <map>
#include <mutex>

#include <android-base/macros.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/IWifiRttController.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.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;

/**
 * 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_6::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<V1_5::IWifiChip::UsableChannelFilter> filterMask,
                                   getUsableChannels_cb _hidl_cb) override;
    Return<void> triggerSubsystemRestart(triggerSubsystemRestart_cb hidl_status_cb) override;
    Return<void> createRttController_1_6(const sp<IWifiIface>& bound_iface,
                                         createRttController_1_6_cb hidl_status_cb) override;
    Return<void> getUsableChannels_1_6(WifiBand band,
                                       hidl_bitfield<V1_5::WifiIfaceMode> ifaceModeMask,
                                       hidl_bitfield<UsableChannelFilter> filterMask,
                                       getUsableChannels_1_6_cb _hidl_cb) override;
    Return<void> getSupportedRadioCombinationsMatrix(
            getSupportedRadioCombinationsMatrix_cb hidl_status_cb) override;
    Return<void> getAvailableModes_1_6(getAvailableModes_1_6_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<V1_0::IWifiChip::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_6::IWifiStaIface>> createStaIfaceInternal();
    std::pair<WifiStatus, std::vector<hidl_string>> getStaIfaceNamesInternal();
    std::pair<WifiStatus, sp<V1_6::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<V1_5::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_6::IWifiChip::ChipConcurrencyCombination>
    getCurrentModeConcurrencyCombinations();
    std::map<IfaceConcurrencyType, size_t> getCurrentConcurrencyCombination();
    std::vector<std::map<IfaceConcurrencyType, size_t>> expandConcurrencyCombinations(
            const V1_6::IWifiChip::ChipConcurrencyCombination& combination);
    bool canExpandedConcurrencyComboSupportConcurrencyTypeWithCurrentTypes(
            const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
            IfaceConcurrencyType requested_type);
    bool canCurrentModeSupportConcurrencyTypeWithCurrentTypes(IfaceConcurrencyType requested_type);
    bool canExpandedConcurrencyComboSupportConcurrencyCombo(
            const std::map<IfaceConcurrencyType, size_t>& expanded_combo,
            const std::map<IfaceConcurrencyType, size_t>& req_combo);
    bool canCurrentModeSupportConcurrencyCombo(
            const std::map<IfaceConcurrencyType, size_t>& req_combo);
    bool canCurrentModeSupportConcurrencyType(IfaceConcurrencyType 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();
    std::pair<WifiStatus, sp<V1_6::IWifiRttController>> createRttControllerInternal_1_6(
            const sp<IWifiIface>& bound_iface);
    std::pair<WifiStatus, std::vector<V1_6::WifiUsableChannel>> getUsableChannelsInternal_1_6(
            WifiBand band, uint32_t ifaceModeMask, uint32_t filterMask);
    std::pair<WifiStatus, WifiRadioCombinationMatrix> getSupportedRadioCombinationsMatrixInternal();
    std::pair<WifiStatus, std::vector<V1_6::IWifiChip::ChipMode>> getAvailableModesInternal_1_6();

    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_6::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_