Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove HIDL implementation for the WiFi

Browse Source 
Vendor HAL.

Bug: 274964641
Test: Treehugger builds.
Change-Id: I0198870790077f1ca03c663d58aac53eb4a64b83
This commit is contained in:
Gabriel Biren
2023-04-06 21:01:59 +00:00
parent 9074fdc1da
commit 7b65166e33
80 changed files with 0 additions and 23317 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
wifi/1.6/default/Android.bp
View File

@@ -1,242 +0,0 @@
// Copyright (C) 2021 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.
package {
default_applicable_licenses: ["hardware_interfaces_license"],
}
soong_config_module_type {
name: "wifi_hal_cc_defaults",
module_type: "cc_defaults",
config_namespace: "wifi",
bool_variables: [
"hidl_feature_aware", // WIFI_HIDL_FEATURE_AWARE
"hidl_feature_dual_interface", // WIFI_HIDL_FEATURE_DUAL_INTERFACE
"hidl_feature_disable_ap", // WIFI_HIDL_FEATURE_DISABLE_AP
"hidl_feature_disable_ap_mac_randomization", // WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
"avoid_iface_reset_mac_change", // WIFI_AVOID_IFACE_RESET_MAC_CHANGE
"wifi_skip_state_toggle_off_on_for_nan", // WIFI_SKIP_STATE_TOGGLE_OFF_ON_FOR_NAN
],
value_variables: [
"hal_interface_combinations", // WIFI_HAL_INTERFACE_COMBINATIONS
],
properties: [
"cppflags",
],
}
wifi_hal_cc_defaults {
name: "android.hardware.wifi@1.0-service-cppflags-defaults",
soong_config_variables: {
hidl_feature_aware: {
cppflags: ["-DWIFI_HIDL_FEATURE_AWARE"],
},
hidl_feature_dual_interface: {
cppflags: ["-DWIFI_HIDL_FEATURE_DUAL_INTERFACE"],
},
hidl_feature_disable_ap: {
cppflags: ["-DWIFI_HIDL_FEATURE_DISABLE_AP"],
},
hidl_feature_disable_ap_mac_randomization: {
cppflags: ["-DWIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION"],
},
avoid_iface_reset_mac_change: {
cppflags: ["-DWIFI_AVOID_IFACE_RESET_MAC_CHANGE"],
},
wifi_skip_state_toggle_off_on_for_nan: {
cppflags: ["-DWIFI_SKIP_STATE_TOGGLE_OFF_ON_FOR_NAN"],
},
hal_interface_combinations: {
cppflags: ["-DWIFI_HAL_INTERFACE_COMBINATIONS=%s"],
},
},
}
cc_library_static {
name: "android.hardware.wifi@1.0-service-lib",
defaults: ["android.hardware.wifi@1.0-service-cppflags-defaults"],
proprietary: true,
compile_multilib: "first",
cppflags: [
"-Wall",
"-Werror",
"-Wextra",
],
// Allow implicit fallthroughs in wifi_legacy_hal.cpp until they are fixed.
cflags: ["-Wno-error=implicit-fallthrough"],
srcs: [
"hidl_struct_util.cpp",
"hidl_sync_util.cpp",
"ringbuffer.cpp",
"wifi.cpp",
"wifi_ap_iface.cpp",
"wifi_chip.cpp",
"wifi_feature_flags.cpp",
"wifi_iface_util.cpp",
"wifi_legacy_hal.cpp",
"wifi_legacy_hal_factory.cpp",
"wifi_legacy_hal_stubs.cpp",
"wifi_mode_controller.cpp",
"wifi_nan_iface.cpp",
"wifi_p2p_iface.cpp",
"wifi_rtt_controller.cpp",
"wifi_sta_iface.cpp",
"wifi_status_util.cpp",
],
shared_libs: [
"libbase",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
],
export_include_dirs: ["."],
}
cc_binary {
name: "android.hardware.wifi@1.0-service",
vintf_fragments: ["android.hardware.wifi@1.0-service.xml"],
relative_install_path: "hw",
proprietary: true,
cppflags: [
"-Wall",
"-Werror",
"-Wextra",
],
srcs: ["service.cpp"],
shared_libs: [
"libbase",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
],
static_libs: ["android.hardware.wifi@1.0-service-lib"],
init_rc: ["android.hardware.wifi@1.0-service.rc"],
}
cc_binary {
name: "android.hardware.wifi@1.0-service-lazy",
vintf_fragments: ["android.hardware.wifi@1.0-service.xml"],
overrides: ["android.hardware.wifi@1.0-service"],
cflags: ["-DLAZY_SERVICE"],
relative_install_path: "hw",
proprietary: true,
cppflags: [
"-Wall",
"-Werror",
"-Wextra",
],
srcs: ["service.cpp"],
shared_libs: [
"libbase",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
"libxml2",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
],
static_libs: ["android.hardware.wifi@1.0-service-lib"],
init_rc: ["android.hardware.wifi@1.0-service-lazy.rc"],
}
cc_test {
name: "android.hardware.wifi@1.0-service-tests",
proprietary: true,
compile_multilib: "first",
cppflags: [
"-Wall",
"-Werror",
"-Wextra",
],
srcs: [
"tests/hidl_struct_util_unit_tests.cpp",
"tests/main.cpp",
"tests/mock_interface_tool.cpp",
"tests/mock_wifi_feature_flags.cpp",
"tests/mock_wifi_iface_util.cpp",
"tests/mock_wifi_legacy_hal.cpp",
"tests/mock_wifi_mode_controller.cpp",
"tests/ringbuffer_unit_tests.cpp",
"tests/wifi_nan_iface_unit_tests.cpp",
"tests/wifi_chip_unit_tests.cpp",
"tests/wifi_iface_util_unit_tests.cpp",
],
static_libs: [
"libgmock",
"libgtest",
"android.hardware.wifi@1.0",
"android.hardware.wifi@1.1",
"android.hardware.wifi@1.2",
"android.hardware.wifi@1.3",
"android.hardware.wifi@1.4",
"android.hardware.wifi@1.5",
"android.hardware.wifi@1.6",
"android.hardware.wifi@1.0-service-lib",
],
shared_libs: [
"libbase",
"libcutils",
"libhidlbase",
"liblog",
"libnl",
"libutils",
"libwifi-hal",
"libwifi-system-iface",
],
}
filegroup {
name: "default-android.hardware.wifi@1.0-service.rc",
srcs: ["android.hardware.wifi@1.0-service.rc"],
}
filegroup {
name: "default-android.hardware.wifi@1.0-service.xml",
srcs: ["android.hardware.wifi@1.0-service.xml"],
}

35
wifi/1.6/default/THREADING.README
View File

@@ -1,35 +0,0 @@
Vendor HAL Threading Model
==========================
The vendor HAL service has two threads:
1. HIDL thread: This is the main thread which processes all the incoming HIDL
RPC's.
2. Legacy HAL event loop thread: This is the thread forked off for processing
the legacy HAL event loop (wifi_event_loop()). This thread is used to process
any asynchronous netlink events posted by the driver. Any asynchronous
callbacks passed to the legacy HAL API's are invoked on this thread.
Synchronization Concerns
========================
wifi_legacy_hal.cpp has a bunch of global "C" style functions to handle the
legacy callbacks. Each of these "C" style function invokes a corresponding
"std::function" version of the callback which does the actual processing.
The variables holding these "std::function" callbacks are reset from the HIDL
thread when they are no longer used. For example: stopGscan() will reset the
corresponding "on_gscan_*" callback variables which were set when startGscan()
was invoked. This is not thread safe since these callback variables are
accesed from the legacy hal event loop thread as well.
Synchronization Solution
========================
Adding a global lock seems to be the most trivial solution to the problem.
a) All of the asynchronous "C" style callbacks will acquire the global lock
before invoking the corresponding "std::function" callback variables.
b) All of the HIDL methods will also acquire the global lock before processing
(in hidl_return_util::validateAndCall()).
Note: It's important that we only acquire the global lock for asynchronous
callbacks, because there is no guarantee (or documentation to clarify) that the
synchronous callbacks are invoked on the same invocation thread. If that is not
the case in some implementation, we will end up deadlocking the system since the
HIDL thread would have acquired the global lock which is needed by the
synchronous callback executed on the legacy hal event loop thread.

14
wifi/1.6/default/android.hardware.wifi@1.0-service-lazy.rc
View File

@@ -1,14 +0,0 @@
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service-lazy
interface android.hardware.wifi@1.0::IWifi default
interface android.hardware.wifi@1.1::IWifi default
interface android.hardware.wifi@1.2::IWifi default
interface android.hardware.wifi@1.3::IWifi default
interface android.hardware.wifi@1.4::IWifi default
interface android.hardware.wifi@1.5::IWifi default
interface android.hardware.wifi@1.6::IWifi default
oneshot
disabled
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps

12
wifi/1.6/default/android.hardware.wifi@1.0-service.rc
View File

@@ -1,12 +0,0 @@
service vendor.wifi_hal_legacy /vendor/bin/hw/android.hardware.wifi@1.0-service
interface android.hardware.wifi@1.0::IWifi default
interface android.hardware.wifi@1.1::IWifi default
interface android.hardware.wifi@1.2::IWifi default
interface android.hardware.wifi@1.3::IWifi default
interface android.hardware.wifi@1.4::IWifi default
interface android.hardware.wifi@1.5::IWifi default
interface android.hardware.wifi@1.6::IWifi default
class hal
capabilities NET_ADMIN NET_RAW SYS_MODULE
user wifi
group wifi gps

11
wifi/1.6/default/android.hardware.wifi@1.0-service.xml
View File

@@ -1,11 +0,0 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.wifi</name>
<transport>hwbinder</transport>
<version>1.6</version>
<interface>
<name>IWifi</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

66
wifi/1.6/default/hal_legacy/AudioHardwareBase.h
View File

@@ -1,66 +0,0 @@
/*
* Copyright (C) 2007 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 ANDROID_AUDIO_HARDWARE_BASE_H
#define ANDROID_AUDIO_HARDWARE_BASE_H
#include <hardware_legacy/AudioHardwareInterface.h>
#include <system/audio.h>
namespace android_audio_legacy {
// ----------------------------------------------------------------------------
/**
* AudioHardwareBase is a convenient base class used for implementing the
* AudioHardwareInterface interface.
*/
class AudioHardwareBase : public AudioHardwareInterface {
public:
AudioHardwareBase();
virtual ~AudioHardwareBase() {}
/**
* setMode is called when the audio mode changes. NORMAL mode is for
* standard audio playback, RINGTONE when a ringtone is playing, IN_CALL
* when a telephony call is in progress, IN_COMMUNICATION when a VoIP call is in progress.
*/
virtual status_t setMode(int mode);
virtual status_t setParameters(const String8& keyValuePairs);
virtual String8 getParameters(const String8& keys);
virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount);
virtual status_t getMasterVolume(float* volume);
/**This method dumps the state of the audio hardware */
virtual status_t dumpState(int fd, const Vector<String16>& args);
protected:
/** returns true if the given mode maps to a telephony or VoIP call is in progress */
virtual bool isModeInCall(int mode) {
return ((mode == AudioSystem::MODE_IN_CALL) ||
(mode == AudioSystem::MODE_IN_COMMUNICATION));
};
/** returns true if a telephony or VoIP call is in progress */
virtual bool isInCall() { return isModeInCall(mMode); };
int mMode;
};
}; // namespace android_audio_legacy
#endif // ANDROID_AUDIO_HARDWARE_BASE_H

296
wifi/1.6/default/hal_legacy/AudioHardwareInterface.h
View File

@@ -1,296 +0,0 @@
/*
* Copyright (C) 2007 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 ANDROID_AUDIO_HARDWARE_INTERFACE_H
#define ANDROID_AUDIO_HARDWARE_INTERFACE_H
#include <stdint.h>
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/String16.h>
#include <utils/String8.h>
#include <utils/Vector.h>
#include <hardware_legacy/AudioSystemLegacy.h>
#include <hardware/audio.h>
#include <system/audio.h>
#include <cutils/bitops.h>
namespace android_audio_legacy {
using android::String16;
using android::String8;
using android::Vector;
// ----------------------------------------------------------------------------
/**
* AudioStreamOut is the abstraction interface for the audio output hardware.
*
* It provides information about various properties of the audio output hardware driver.
*/
class AudioStreamOut {
public:
virtual ~AudioStreamOut() = 0;
/** return audio sampling rate in hz - eg. 44100 */
virtual uint32_t sampleRate() const = 0;
/** returns size of output buffer - eg. 4800 */
virtual size_t bufferSize() const = 0;
/**
* returns the output channel mask
*/
virtual uint32_t channels() const = 0;
/**
* return audio format in 8bit or 16bit PCM format -
* eg. AudioSystem:PCM_16_BIT
*/
virtual int format() const = 0;
/**
* return the frame size (number of bytes per sample).
*/
uint32_t frameSize() const {
return audio_channel_count_from_out_mask(channels()) *
((format() == AUDIO_FORMAT_PCM_16_BIT) ? sizeof(int16_t) : sizeof(int8_t));
}
/**
* return the audio hardware driver latency in milli seconds.
*/
virtual uint32_t latency() const = 0;
/**
* Use this method in situations where audio mixing is done in the
* hardware. This method serves as a direct interface with hardware,
* allowing you to directly set the volume as apposed to via the framework.
* This method might produce multiple PCM outputs or hardware accelerated
* codecs, such as MP3 or AAC.
*/
virtual status_t setVolume(float left, float right) = 0;
/** write audio buffer to driver. Returns number of bytes written */
virtual ssize_t write(const void* buffer, size_t bytes) = 0;
/**
* Put the audio hardware output into standby mode. Returns
* status based on include/utils/Errors.h
*/
virtual status_t standby() = 0;
/** dump the state of the audio output device */
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
// set/get audio output parameters. The function accepts a list of parameters
// key value pairs in the form: key1=value1;key2=value2;...
// Some keys are reserved for standard parameters (See AudioParameter class).
// If the implementation does not accept a parameter change while the output is
// active but the parameter is acceptable otherwise, it must return INVALID_OPERATION.
// The audio flinger will put the output in standby and then change the parameter value.
virtual status_t setParameters(const String8& keyValuePairs) = 0;
virtual String8 getParameters(const String8& keys) = 0;
// return the number of audio frames written by the audio dsp to DAC since
// the output has exited standby
virtual status_t getRenderPosition(uint32_t* dspFrames) = 0;
/**
* get the local time at which the next write to the audio driver will be
* presented
*/
virtual status_t getNextWriteTimestamp(int64_t* timestamp);
/**
* Return a recent count of the number of audio frames presented to an external observer.
*/
virtual status_t getPresentationPosition(uint64_t* frames, struct timespec* timestamp);
};
/**
* AudioStreamIn is the abstraction interface for the audio input hardware.
*
* It defines the various properties of the audio hardware input driver.
*/
class AudioStreamIn {
public:
virtual ~AudioStreamIn() = 0;
/** return audio sampling rate in hz - eg. 44100 */
virtual uint32_t sampleRate() const = 0;
/** return the input buffer size allowed by audio driver */
virtual size_t bufferSize() const = 0;
/** return input channel mask */
virtual uint32_t channels() const = 0;
/**
* return audio format in 8bit or 16bit PCM format -
* eg. AudioSystem:PCM_16_BIT
*/
virtual int format() const = 0;
/**
* return the frame size (number of bytes per sample).
*/
uint32_t frameSize() const {
return audio_channel_count_from_in_mask(channels()) *
((format() == AudioSystem::PCM_16_BIT) ? sizeof(int16_t) : sizeof(int8_t));
}
/** set the input gain for the audio driver. This method is for
* for future use */
virtual status_t setGain(float gain) = 0;
/** read audio buffer in from audio driver */
virtual ssize_t read(void* buffer, ssize_t bytes) = 0;
/** dump the state of the audio input device */
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
/**
* Put the audio hardware input into standby mode. Returns
* status based on include/utils/Errors.h
*/
virtual status_t standby() = 0;
// set/get audio input parameters. The function accepts a list of parameters
// key value pairs in the form: key1=value1;key2=value2;...
// Some keys are reserved for standard parameters (See AudioParameter class).
// If the implementation does not accept a parameter change while the output is
// active but the parameter is acceptable otherwise, it must return INVALID_OPERATION.
// The audio flinger will put the input in standby and then change the parameter value.
virtual status_t setParameters(const String8& keyValuePairs) = 0;
virtual String8 getParameters(const String8& keys) = 0;
// Return the number of input frames lost in the audio driver since the last call of this
// function. Audio driver is expected to reset the value to 0 and restart counting upon
// returning the current value by this function call. Such loss typically occurs when the user
// space process is blocked longer than the capacity of audio driver buffers. Unit: the number
// of input audio frames
virtual unsigned int getInputFramesLost() const = 0;
virtual status_t addAudioEffect(effect_handle_t effect) = 0;
virtual status_t removeAudioEffect(effect_handle_t effect) = 0;
};
/**
* AudioHardwareInterface.h defines the interface to the audio hardware abstraction layer.
*
* The interface supports setting and getting parameters, selecting audio routing
* paths, and defining input and output streams.
*
* AudioFlinger initializes the audio hardware and immediately opens an output stream.
* You can set Audio routing to output to handset, speaker, Bluetooth, or a headset.
*
* The audio input stream is initialized when AudioFlinger is called to carry out
* a record operation.
*/
class AudioHardwareInterface {
public:
virtual ~AudioHardwareInterface() {}
/**
* check to see if the audio hardware interface has been initialized.
* return status based on values defined in include/utils/Errors.h
*/
virtual status_t initCheck() = 0;
/** set the audio volume of a voice call. Range is between 0.0 and 1.0 */
virtual status_t setVoiceVolume(float volume) = 0;
/**
* set the audio volume for all audio activities other than voice call.
* Range between 0.0 and 1.0. If any value other than NO_ERROR is returned,
* the software mixer will emulate this capability.
*/
virtual status_t setMasterVolume(float volume) = 0;
/**
* Get the current master volume value for the HAL, if the HAL supports
* master volume control. AudioFlinger will query this value from the
* primary audio HAL when the service starts and use the value for setting
* the initial master volume across all HALs.
*/
virtual status_t getMasterVolume(float* volume) = 0;
/**
* setMode is called when the audio mode changes. NORMAL mode is for
* standard audio playback, RINGTONE when a ringtone is playing, and IN_CALL
* when a call is in progress.
*/
virtual status_t setMode(int mode) = 0;
// mic mute
virtual status_t setMicMute(bool state) = 0;
virtual status_t getMicMute(bool* state) = 0;
// set/get global audio parameters
virtual status_t setParameters(const String8& keyValuePairs) = 0;
virtual String8 getParameters(const String8& keys) = 0;
// Returns audio input buffer size according to parameters passed or 0 if one of the
// parameters is not supported
virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount) = 0;
/** This method creates and opens the audio hardware output stream */
virtual AudioStreamOut* openOutputStream(uint32_t devices, int* format = 0,
uint32_t* channels = 0, uint32_t* sampleRate = 0,
status_t* status = 0) = 0;
virtual AudioStreamOut* openOutputStreamWithFlags(
uint32_t devices, audio_output_flags_t flags = (audio_output_flags_t)0, int* format = 0,
uint32_t* channels = 0, uint32_t* sampleRate = 0, status_t* status = 0) = 0;
virtual void closeOutputStream(AudioStreamOut* out) = 0;
/** This method creates and opens the audio hardware input stream */
virtual AudioStreamIn* openInputStream(uint32_t devices, int* format, uint32_t* channels,
uint32_t* sampleRate, status_t* status,
AudioSystem::audio_in_acoustics acoustics) = 0;
virtual void closeInputStream(AudioStreamIn* in) = 0;
/**This method dumps the state of the audio hardware */
virtual status_t dumpState(int fd, const Vector<String16>& args) = 0;
virtual status_t setMasterMute(bool muted) = 0;
static AudioHardwareInterface* create();
virtual int createAudioPatch(unsigned int num_sources, const struct audio_port_config* sources,
unsigned int num_sinks, const struct audio_port_config* sinks,
audio_patch_handle_t* handle) = 0;
virtual int releaseAudioPatch(audio_patch_handle_t handle) = 0;
virtual int getAudioPort(struct audio_port* port) = 0;
virtual int setAudioPortConfig(const struct audio_port_config* config) = 0;
protected:
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
};
// ----------------------------------------------------------------------------
extern "C" AudioHardwareInterface* createAudioHardware(void);
}; // namespace android_audio_legacy
#endif // ANDROID_AUDIO_HARDWARE_INTERFACE_H

249
wifi/1.6/default/hal_legacy/AudioPolicyInterface.h
View File

@@ -1,249 +0,0 @@
/*
* Copyright (C) 2009 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 ANDROID_AUDIOPOLICYINTERFACE_H
#define ANDROID_AUDIOPOLICYINTERFACE_H
#include <media/AudioSystem.h>
#include <media/ToneGenerator.h>
#include <utils/String8.h>
#include <hardware/audio_policy.h>
#include <hardware_legacy/AudioSystemLegacy.h>
namespace android_audio_legacy {
using android::String8;
using android::ToneGenerator;
using android::Vector;
// ----------------------------------------------------------------------------
// The AudioPolicyInterface and AudioPolicyClientInterface classes define the communication
// interfaces between the platform specific audio policy manager and Android generic audio policy
// manager. The platform specific audio policy manager must implement methods of the
// AudioPolicyInterface class. This implementation makes use of the AudioPolicyClientInterface to
// control the activity and configuration of audio input and output streams.
//
// The platform specific audio policy manager is in charge of the audio routing and volume control
// policies for a given platform.
// The main roles of this module are:
// - keep track of current system state (removable device connections, phone state, user
// requests...). System state changes and user actions are notified to audio policy manager with
// methods of the AudioPolicyInterface.
// - process getOutput() queries received when AudioTrack objects are created: Those queries
// return a handler on an output that has been selected, configured and opened by the audio policy
// manager and that must be used by the AudioTrack when registering to the AudioFlinger with the
// createTrack() method. When the AudioTrack object is released, a putOutput() query is received
// and the audio policy manager can decide to close or reconfigure the output depending on other
// streams using this output and current system state.
// - similarly process getInput() and putInput() queries received from AudioRecord objects and
// configure audio inputs.
// - process volume control requests: the stream volume is converted from an index value (received
// from UI) to a float value applicable to each output as a function of platform specific settings
// and current output route (destination device). It also make sure that streams are not muted if
// not allowed (e.g. camera shutter sound in some countries).
//
// The platform specific audio policy manager is provided as a shared library by platform vendors
// (as for libaudio.so) and is linked with libaudioflinger.so
// Audio Policy Manager Interface
class AudioPolicyInterface {
public:
virtual ~AudioPolicyInterface() {}
//
// configuration functions
//
// indicate a change in device connection status
virtual status_t setDeviceConnectionState(audio_devices_t device,
AudioSystem::device_connection_state state,
const char* device_address) = 0;
// retrieve a device connection status
virtual AudioSystem::device_connection_state getDeviceConnectionState(
audio_devices_t device, const char* device_address) = 0;
// indicate a change in phone state. Valid phones states are defined by AudioSystem::audio_mode
virtual void setPhoneState(int state) = 0;
// force using a specific device category for the specified usage
virtual void setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config) = 0;
// retrieve current device category forced for a given usage
virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage) = 0;
// set a system property (e.g. camera sound always audible)
virtual void setSystemProperty(const char* property, const char* value) = 0;
// check proper initialization
virtual status_t initCheck() = 0;
//
// Audio routing query functions
//
// request an output appropriate for playback of the supplied stream type and parameters
virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream, uint32_t samplingRate,
audio_format_t format, audio_channel_mask_t channelMask,
AudioSystem::output_flags flags,
const audio_offload_info_t* offloadInfo) = 0;
// indicates to the audio policy manager that the output starts being used by corresponding
// stream.
virtual status_t startOutput(audio_io_handle_t output, AudioSystem::stream_type stream,
audio_session_t session = AUDIO_SESSION_NONE) = 0;
// indicates to the audio policy manager that the output stops being used by corresponding
// stream.
virtual status_t stopOutput(audio_io_handle_t output, AudioSystem::stream_type stream,
audio_session_t session = AUDIO_SESSION_NONE) = 0;
// releases the output.
virtual void releaseOutput(audio_io_handle_t output) = 0;
// request an input appropriate for record from the supplied device with supplied parameters.
virtual audio_io_handle_t getInput(int inputSource, uint32_t samplingRate,
audio_format_t format, audio_channel_mask_t channelMask,
AudioSystem::audio_in_acoustics acoustics) = 0;
// indicates to the audio policy manager that the input starts being used.
virtual status_t startInput(audio_io_handle_t input) = 0;
// indicates to the audio policy manager that the input stops being used.
virtual status_t stopInput(audio_io_handle_t input) = 0;
// releases the input.
virtual void releaseInput(audio_io_handle_t input) = 0;
//
// volume control functions
//
// initialises stream volume conversion parameters by specifying volume index range.
virtual void initStreamVolume(AudioSystem::stream_type stream, int indexMin, int indexMax) = 0;
// sets the new stream volume at a level corresponding to the supplied index for the
// supplied device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT means
// setting volume for all devices
virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index,
audio_devices_t device) = 0;
// retrieve current volume index for the specified stream and the
// specified device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT means
// querying the volume of the active device.
virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int* index,
audio_devices_t device) = 0;
// return the strategy corresponding to a given stream type
virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream) = 0;
// return the enabled output devices for the given stream type
virtual audio_devices_t getDevicesForStream(AudioSystem::stream_type stream) = 0;
// Audio effect management
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t* desc) = 0;
virtual status_t registerEffect(const effect_descriptor_t* desc, audio_io_handle_t io,
uint32_t strategy, audio_session_t session, int id) = 0;
virtual status_t unregisterEffect(int id) = 0;
virtual status_t setEffectEnabled(int id, bool enabled) = 0;
virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const = 0;
virtual bool isStreamActiveRemotely(int stream, uint32_t inPastMs = 0) const = 0;
virtual bool isSourceActive(audio_source_t source) const = 0;
// dump state
virtual status_t dump(int fd) = 0;
virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo) = 0;
};
// Audio Policy client Interface
class AudioPolicyClientInterface {
public:
virtual ~AudioPolicyClientInterface() {}
//
// Audio HW module functions
//
// loads a HW module.
virtual audio_module_handle_t loadHwModule(const char* name) = 0;
//
// Audio output Control functions
//
// opens an audio output with the requested parameters. The parameter values can indicate to use
// the default values in case the audio policy manager has no specific requirements for the
// output being opened. When the function returns, the parameter values reflect the actual
// values used by the audio hardware output stream. The audio policy manager can check if the
// proposed parameters are suitable or not and act accordingly.
virtual audio_io_handle_t openOutput(audio_module_handle_t module, audio_devices_t* pDevices,
uint32_t* pSamplingRate, audio_format_t* pFormat,
audio_channel_mask_t* pChannelMask, uint32_t* pLatencyMs,
audio_output_flags_t flags,
const audio_offload_info_t* offloadInfo = NULL) = 0;
// creates a special output that is duplicated to the two outputs passed as arguments. The
// duplication is performed by a special mixer thread in the AudioFlinger.
virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
audio_io_handle_t output2) = 0;
// closes the output stream
virtual status_t closeOutput(audio_io_handle_t output) = 0;
// suspends the output. When an output is suspended, the corresponding audio hardware output
// stream is placed in standby and the AudioTracks attached to the mixer thread are still
// processed but the output mix is discarded.
virtual status_t suspendOutput(audio_io_handle_t output) = 0;
// restores a suspended output.
virtual status_t restoreOutput(audio_io_handle_t output) = 0;
//
// Audio input Control functions
//
// opens an audio input
virtual audio_io_handle_t openInput(audio_module_handle_t module, audio_devices_t* pDevices,
uint32_t* pSamplingRate, audio_format_t* pFormat,
audio_channel_mask_t* pChannelMask) = 0;
// closes an audio input
virtual status_t closeInput(audio_io_handle_t input) = 0;
//
// misc control functions
//
// set a stream volume for a particular output. For the same user setting, a given stream type
// can have different volumes for each output (destination device) it is attached to.
virtual status_t setStreamVolume(AudioSystem::stream_type stream, float volume,
audio_io_handle_t output, int delayMs = 0) = 0;
// invalidate a stream type, causing a reroute to an unspecified new output
virtual status_t invalidateStream(AudioSystem::stream_type stream) = 0;
// function enabling to send proprietary informations directly from audio policy manager to
// audio hardware interface.
virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs,
int delayMs = 0) = 0;
// function enabling to receive proprietary informations directly from audio hardware interface
// to audio policy manager.
virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) = 0;
// request the playback of a tone on the specified stream: used for instance to replace
// notification sounds when playing over a telephony device during a phone call.
virtual status_t startTone(ToneGenerator::tone_type tone, AudioSystem::stream_type stream) = 0;
virtual status_t stopTone() = 0;
// set down link audio volume.
virtual status_t setVoiceVolume(float volume, int delayMs = 0) = 0;
// move effect to the specified output
virtual status_t moveEffects(audio_session_t session, audio_io_handle_t srcOutput,
audio_io_handle_t dstOutput) = 0;
};
extern "C" AudioPolicyInterface* createAudioPolicyManager(
AudioPolicyClientInterface* clientInterface);
extern "C" void destroyAudioPolicyManager(AudioPolicyInterface* interface);
}; // namespace android_audio_legacy
#endif // ANDROID_AUDIOPOLICYINTERFACE_H

567
wifi/1.6/default/hal_legacy/AudioPolicyManagerBase.h
View File

@@ -1,567 +0,0 @@
/*
* Copyright (C) 2009 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.
*/
#include <cutils/config_utils.h>
#include <cutils/misc.h>
#include <hardware_legacy/AudioPolicyInterface.h>
#include <stdint.h>
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/SortedVector.h>
#include <utils/Timers.h>
namespace android_audio_legacy {
using android::DefaultKeyedVector;
using android::KeyedVector;
using android::SortedVector;
// ----------------------------------------------------------------------------
#define MAX_DEVICE_ADDRESS_LEN 20
// Attenuation applied to STRATEGY_SONIFICATION streams when a headset is connected: 6dB
#define SONIFICATION_HEADSET_VOLUME_FACTOR 0.5
// Min volume for STRATEGY_SONIFICATION streams when limited by music volume: -36dB
#define SONIFICATION_HEADSET_VOLUME_MIN 0.016
// Time in milliseconds during which we consider that music is still active after a music
// track was stopped - see computeVolume()
#define SONIFICATION_HEADSET_MUSIC_DELAY 5000
// Time in milliseconds after media stopped playing during which we consider that the
// sonification should be as unobtrusive as during the time media was playing.
#define SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY 5000
// Time in milliseconds during witch some streams are muted while the audio path
// is switched
#define MUTE_TIME_MS 2000
#define NUM_TEST_OUTPUTS 5
#define NUM_VOL_CURVE_KNEES 2
// Default minimum length allowed for offloading a compressed track
// Can be overridden by the audio.offload.min.duration.secs property
#define OFFLOAD_DEFAULT_MIN_DURATION_SECS 60
// ----------------------------------------------------------------------------
// AudioPolicyManagerBase implements audio policy manager behavior common to all platforms.
// Each platform must implement an AudioPolicyManager class derived from AudioPolicyManagerBase
// and override methods for which the platform specific behavior differs from the implementation
// in AudioPolicyManagerBase. Even if no specific behavior is required, the AudioPolicyManager
// class must be implemented as well as the class factory function createAudioPolicyManager()
// and provided in a shared library libaudiopolicy.so.
// ----------------------------------------------------------------------------
class AudioPolicyManagerBase : public AudioPolicyInterface
#ifdef AUDIO_POLICY_TEST
,
public Thread
#endif // AUDIO_POLICY_TEST
{
public:
AudioPolicyManagerBase(AudioPolicyClientInterface* clientInterface);
virtual ~AudioPolicyManagerBase();
// AudioPolicyInterface
virtual status_t setDeviceConnectionState(audio_devices_t device,
AudioSystem::device_connection_state state,
const char* device_address);
virtual AudioSystem::device_connection_state getDeviceConnectionState(
audio_devices_t device, const char* device_address);
virtual void setPhoneState(int state);
virtual void setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config);
virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage);
virtual void setSystemProperty(const char* property, const char* value);
virtual status_t initCheck();
virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream, uint32_t samplingRate,
audio_format_t format, audio_channel_mask_t channelMask,
AudioSystem::output_flags flags,
const audio_offload_info_t* offloadInfo);
virtual status_t startOutput(audio_io_handle_t output, AudioSystem::stream_type stream,
audio_session_t session = AUDIO_SESSION_NONE);
virtual status_t stopOutput(audio_io_handle_t output, AudioSystem::stream_type stream,
audio_session_t session = AUDIO_SESSION_NONE);
virtual void releaseOutput(audio_io_handle_t output);
virtual audio_io_handle_t getInput(int inputSource, uint32_t samplingRate,
audio_format_t format, audio_channel_mask_t channelMask,
AudioSystem::audio_in_acoustics acoustics);
// indicates to the audio policy manager that the input starts being used.
virtual status_t startInput(audio_io_handle_t input);
// indicates to the audio policy manager that the input stops being used.
virtual status_t stopInput(audio_io_handle_t input);
virtual void releaseInput(audio_io_handle_t input);
virtual void closeAllInputs();
virtual void initStreamVolume(AudioSystem::stream_type stream, int indexMin, int indexMax);
virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index,
audio_devices_t device);
virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int* index,
audio_devices_t device);
// return the strategy corresponding to a given stream type
virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream);
// return the enabled output devices for the given stream type
virtual audio_devices_t getDevicesForStream(AudioSystem::stream_type stream);
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t* desc = NULL);
virtual status_t registerEffect(const effect_descriptor_t* desc, audio_io_handle_t io,
uint32_t strategy, audio_session_t session, int id);
virtual status_t unregisterEffect(int id);
virtual status_t setEffectEnabled(int id, bool enabled);
virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const;
// return whether a stream is playing remotely, override to change the definition of
// local/remote playback, used for instance by notification manager to not make
// media players lose audio focus when not playing locally
virtual bool isStreamActiveRemotely(int stream, uint32_t inPastMs = 0) const;
virtual bool isSourceActive(audio_source_t source) const;
virtual status_t dump(int fd);
virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo);
protected:
enum routing_strategy {
STRATEGY_MEDIA,
STRATEGY_PHONE,
STRATEGY_SONIFICATION,
STRATEGY_SONIFICATION_RESPECTFUL,
STRATEGY_DTMF,
STRATEGY_ENFORCED_AUDIBLE,
NUM_STRATEGIES
};
// 4 points to define the volume attenuation curve, each characterized by the volume
// index (from 0 to 100) at which they apply, and the attenuation in dB at that index.
// we use 100 steps to avoid rounding errors when computing the volume in volIndexToAmpl()
enum { VOLMIN = 0, VOLKNEE1 = 1, VOLKNEE2 = 2, VOLMAX = 3, VOLCNT = 4 };
class VolumeCurvePoint {
public:
int mIndex;
float mDBAttenuation;
};
// device categories used for volume curve management.
enum device_category {
DEVICE_CATEGORY_HEADSET,
DEVICE_CATEGORY_SPEAKER,
DEVICE_CATEGORY_EARPIECE,
DEVICE_CATEGORY_CNT
};
class IOProfile;
class HwModule {
public:
HwModule(const char* name);
~HwModule();
void dump(int fd);
const char* const mName; // base name of the audio HW module (primary, a2dp ...)
audio_module_handle_t mHandle;
Vector<IOProfile*> mOutputProfiles; // output profiles exposed by this module
Vector<IOProfile*> mInputProfiles; // input profiles exposed by this module
};
// the IOProfile class describes the capabilities of an output or input stream.
// It is currently assumed that all combination of listed parameters are supported.
// It is used by the policy manager to determine if an output or input is suitable for
// a given use case, open/close it accordingly and connect/disconnect audio tracks
// to/from it.
class IOProfile {
public:
IOProfile(HwModule* module);
~IOProfile();
bool isCompatibleProfile(audio_devices_t device, uint32_t samplingRate,
audio_format_t format, audio_channel_mask_t channelMask,
audio_output_flags_t flags) const;
void dump(int fd);
void log();
// by convention, "0' in the first entry in mSamplingRates, mChannelMasks or mFormats
// indicates the supported parameters should be read from the output stream
// after it is opened for the first time
Vector<uint32_t> mSamplingRates; // supported sampling rates
Vector<audio_channel_mask_t> mChannelMasks; // supported channel masks
Vector<audio_format_t> mFormats; // supported audio formats
audio_devices_t mSupportedDevices; // supported devices (devices this output can be
// routed to)
audio_output_flags_t mFlags; // attribute flags (e.g primary output,
// direct output...). For outputs only.
HwModule* mModule; // audio HW module exposing this I/O stream
};
// default volume curve
static const VolumeCurvePoint sDefaultVolumeCurve[AudioPolicyManagerBase::VOLCNT];
// default volume curve for media strategy
static const VolumeCurvePoint sDefaultMediaVolumeCurve[AudioPolicyManagerBase::VOLCNT];
// volume curve for media strategy on speakers
static const VolumeCurvePoint sSpeakerMediaVolumeCurve[AudioPolicyManagerBase::VOLCNT];
// volume curve for sonification strategy on speakers
static const VolumeCurvePoint sSpeakerSonificationVolumeCurve[AudioPolicyManagerBase::VOLCNT];
static const VolumeCurvePoint
sSpeakerSonificationVolumeCurveDrc[AudioPolicyManagerBase::VOLCNT];
static const VolumeCurvePoint sDefaultSystemVolumeCurve[AudioPolicyManagerBase::VOLCNT];
static const VolumeCurvePoint sDefaultSystemVolumeCurveDrc[AudioPolicyManagerBase::VOLCNT];
static const VolumeCurvePoint sHeadsetSystemVolumeCurve[AudioPolicyManagerBase::VOLCNT];
static const VolumeCurvePoint sDefaultVoiceVolumeCurve[AudioPolicyManagerBase::VOLCNT];
static const VolumeCurvePoint sSpeakerVoiceVolumeCurve[AudioPolicyManagerBase::VOLCNT];
// default volume curves per stream and device category. See initializeVolumeCurves()
static const VolumeCurvePoint* sVolumeProfiles[AudioSystem::NUM_STREAM_TYPES]
[DEVICE_CATEGORY_CNT];
// descriptor for audio outputs. Used to maintain current configuration of each opened audio
// output and keep track of the usage of this output by each audio stream type.
class AudioOutputDescriptor {
public:
AudioOutputDescriptor(const IOProfile* profile);
status_t dump(int fd);
audio_devices_t device() const;
void changeRefCount(AudioSystem::stream_type stream, int delta);
bool isDuplicated() const { return (mOutput1 != NULL && mOutput2 != NULL); }
audio_devices_t supportedDevices();
uint32_t latency();
bool sharesHwModuleWith(const AudioOutputDescriptor* outputDesc);
bool isActive(uint32_t inPastMs = 0) const;
bool isStreamActive(AudioSystem::stream_type stream, uint32_t inPastMs = 0,
nsecs_t sysTime = 0) const;
bool isStrategyActive(routing_strategy strategy, uint32_t inPastMs = 0,
nsecs_t sysTime = 0) const;
audio_io_handle_t mId; // output handle
uint32_t mSamplingRate; //
audio_format_t mFormat; //
audio_channel_mask_t mChannelMask; // output configuration
uint32_t mLatency; //
audio_output_flags_t mFlags; //
audio_devices_t mDevice; // current device this output is routed to
uint32_t mRefCount[AudioSystem::NUM_STREAM_TYPES]; // number of streams of each type using
// this output
nsecs_t mStopTime[AudioSystem::NUM_STREAM_TYPES];
AudioOutputDescriptor* mOutput1; // used by duplicated outputs: first output
AudioOutputDescriptor* mOutput2; // used by duplicated outputs: second output
float mCurVolume[AudioSystem::NUM_STREAM_TYPES]; // current stream volume
int mMuteCount[AudioSystem::NUM_STREAM_TYPES]; // mute request counter
const IOProfile* mProfile; // I/O profile this output derives from
bool mStrategyMutedByDevice[NUM_STRATEGIES]; // strategies muted because of incompatible
// device selection. See
// checkDeviceMuteStrategies()
uint32_t mDirectOpenCount; // number of clients using this output (direct outputs only)
bool mForceRouting; // Next routing for this output will be forced as current device routed
// is null
};
// descriptor for audio inputs. Used to maintain current configuration of each opened audio
// input and keep track of the usage of this input.
class AudioInputDescriptor {
public:
AudioInputDescriptor(const IOProfile* profile);
status_t dump(int fd);
audio_io_handle_t mId; // input handle
uint32_t mSamplingRate; //
audio_format_t mFormat; // input configuration
audio_channel_mask_t mChannelMask; //
audio_devices_t mDevice; // current device this input is routed to
uint32_t mRefCount; // number of AudioRecord clients using this output
int mInputSource; // input source selected by application (mediarecorder.h)
const IOProfile* mProfile; // I/O profile this output derives from
};
// stream descriptor used for volume control
class StreamDescriptor {
public:
StreamDescriptor();
int getVolumeIndex(audio_devices_t device);
void dump(int fd);
int mIndexMin; // min volume index
int mIndexMax; // max volume index
KeyedVector<audio_devices_t, int> mIndexCur; // current volume index per device
bool mCanBeMuted; // true is the stream can be muted
const VolumeCurvePoint* mVolumeCurve[DEVICE_CATEGORY_CNT];
};
// stream descriptor used for volume control
class EffectDescriptor {
public:
status_t dump(int fd);
int mIo; // io the effect is attached to
routing_strategy mStrategy; // routing strategy the effect is associated to
audio_session_t mSession; // audio session the effect is on
effect_descriptor_t mDesc; // effect descriptor
bool mEnabled; // enabled state: CPU load being used or not
};
void addOutput(audio_io_handle_t id, AudioOutputDescriptor* outputDesc);
void addInput(audio_io_handle_t id, AudioInputDescriptor* inputDesc);
// return the strategy corresponding to a given stream type
static routing_strategy getStrategy(AudioSystem::stream_type stream);
// return appropriate device for streams handled by the specified strategy according to current
// phone state, connected devices...
// if fromCache is true, the device is returned from mDeviceForStrategy[],
// otherwise it is determine by current state
// (device connected,phone state, force use, a2dp output...)
// This allows to:
// 1 speed up process when the state is stable (when starting or stopping an output)
// 2 access to either current device selection (fromCache == true) or
// "future" device selection (fromCache == false) when called from a context
// where conditions are changing (setDeviceConnectionState(), setPhoneState()...) AND
// before updateDevicesAndOutputs() is called.
virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy, bool fromCache);
// change the route of the specified output. Returns the number of ms we have slept to
// allow new routing to take effect in certain cases.
uint32_t setOutputDevice(audio_io_handle_t output, audio_devices_t device, bool force = false,
int delayMs = 0);
// select input device corresponding to requested audio source
virtual audio_devices_t getDeviceForInputSource(int inputSource);
// return io handle of active input or 0 if no input is active
// Only considers inputs from physical devices (e.g. main mic, headset mic) when
// ignoreVirtualInputs is true.
audio_io_handle_t getActiveInput(bool ignoreVirtualInputs = true);
// initialize volume curves for each strategy and device category
void initializeVolumeCurves();
// compute the actual volume for a given stream according to the requested index and a
// particular device
virtual float computeVolume(int stream, int index, audio_io_handle_t output,
audio_devices_t device);
// check that volume change is permitted, compute and send new volume to audio hardware
status_t checkAndSetVolume(int stream, int index, audio_io_handle_t output,
audio_devices_t device, int delayMs = 0, bool force = false);
// apply all stream volumes to the specified output and device
void applyStreamVolumes(audio_io_handle_t output, audio_devices_t device, int delayMs = 0,
bool force = false);
// Mute or unmute all streams handled by the specified strategy on the specified output
void setStrategyMute(routing_strategy strategy, bool on, audio_io_handle_t output,
int delayMs = 0, audio_devices_t device = (audio_devices_t)0);
// Mute or unmute the stream on the specified output
void setStreamMute(int stream, bool on, audio_io_handle_t output, int delayMs = 0,
audio_devices_t device = (audio_devices_t)0);
// handle special cases for sonification strategy while in call: mute streams or replace by
// a special tone in the device used for communication
void handleIncallSonification(int stream, bool starting, bool stateChange);
// true if device is in a telephony or VoIP call
virtual bool isInCall();
// true if given state represents a device in a telephony or VoIP call
virtual bool isStateInCall(int state);
// when a device is connected, checks if an open output can be routed
// to this device. If none is open, tries to open one of the available outputs.
// Returns an output suitable to this device or 0.
// when a device is disconnected, checks if an output is not used any more and
// returns its handle if any.
// transfers the audio tracks and effects from one output thread to another accordingly.
status_t checkOutputsForDevice(audio_devices_t device,
AudioSystem::device_connection_state state,
SortedVector<audio_io_handle_t>& outputs,
const String8 paramStr);
status_t checkInputsForDevice(audio_devices_t device,
AudioSystem::device_connection_state state,
SortedVector<audio_io_handle_t>& inputs, const String8 paramStr);
// close an output and its companion duplicating output.
void closeOutput(audio_io_handle_t output);
// checks and if necessary changes outputs used for all strategies.
// must be called every time a condition that affects the output choice for a given strategy
// changes: connected device, phone state, force use...
// Must be called before updateDevicesAndOutputs()
void checkOutputForStrategy(routing_strategy strategy);
// Same as checkOutputForStrategy() but for a all strategies in order of priority
void checkOutputForAllStrategies();
// manages A2DP output suspend/restore according to phone state and BT SCO usage
void checkA2dpSuspend();
// returns the A2DP output handle if it is open or 0 otherwise
audio_io_handle_t getA2dpOutput();
// selects the most appropriate device on output for current state
// must be called every time a condition that affects the device choice for a given output is
// changed: connected device, phone state, force use, output start, output stop..
// see getDeviceForStrategy() for the use of fromCache parameter
audio_devices_t getNewDevice(audio_io_handle_t output, bool fromCache);
// updates cache of device used by all strategies (mDeviceForStrategy[])
// must be called every time a condition that affects the device choice for a given strategy is
// changed: connected device, phone state, force use...
// cached values are used by getDeviceForStrategy() if parameter fromCache is true.
// Must be called after checkOutputForAllStrategies()
void updateDevicesAndOutputs();
virtual uint32_t getMaxEffectsCpuLoad();
virtual uint32_t getMaxEffectsMemory();
#ifdef AUDIO_POLICY_TEST
virtual bool threadLoop();
void exit();
int testOutputIndex(audio_io_handle_t output);
#endif // AUDIO_POLICY_TEST
status_t setEffectEnabled(EffectDescriptor* pDesc, bool enabled);
// returns the category the device belongs to with regard to volume curve management
static device_category getDeviceCategory(audio_devices_t device);
// extract one device relevant for volume control from multiple device selection
static audio_devices_t getDeviceForVolume(audio_devices_t device);
SortedVector<audio_io_handle_t> getOutputsForDevice(
audio_devices_t device,
DefaultKeyedVector<audio_io_handle_t, AudioOutputDescriptor*> openOutputs);
bool vectorsEqual(SortedVector<audio_io_handle_t>& outputs1,
SortedVector<audio_io_handle_t>& outputs2);
// mute/unmute strategies using an incompatible device combination
// if muting, wait for the audio in pcm buffer to be drained before proceeding
// if unmuting, unmute only after the specified delay
// Returns the number of ms waited
uint32_t checkDeviceMuteStrategies(AudioOutputDescriptor* outputDesc,
audio_devices_t prevDevice, uint32_t delayMs);
audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs,
AudioSystem::output_flags flags);
IOProfile* getInputProfile(audio_devices_t device, uint32_t samplingRate, audio_format_t format,
audio_channel_mask_t channelMask);
IOProfile* getProfileForDirectOutput(audio_devices_t device, uint32_t samplingRate,
audio_format_t format, audio_channel_mask_t channelMask,
audio_output_flags_t flags);
audio_io_handle_t selectOutputForEffects(const SortedVector<audio_io_handle_t>& outputs);
bool isNonOffloadableEffectEnabled();
//
// Audio policy configuration file parsing (audio_policy.conf)
//
static uint32_t stringToEnum(const struct StringToEnum* table, size_t size, const char* name);
static bool stringToBool(const char* value);
static audio_output_flags_t parseFlagNames(char* name);
static audio_devices_t parseDeviceNames(char* name);
void loadSamplingRates(char* name, IOProfile* profile);
void loadFormats(char* name, IOProfile* profile);
void loadOutChannels(char* name, IOProfile* profile);
void loadInChannels(char* name, IOProfile* profile);
status_t loadOutput(cnode* root, HwModule* module);
status_t loadInput(cnode* root, HwModule* module);
void loadHwModule(cnode* root);
void loadHwModules(cnode* root);
void loadGlobalConfig(cnode* root);
status_t loadAudioPolicyConfig(const char* path);
void defaultAudioPolicyConfig(void);
AudioPolicyClientInterface* mpClientInterface; // audio policy client interface
audio_io_handle_t mPrimaryOutput; // primary output handle
// list of descriptors for outputs currently opened
DefaultKeyedVector<audio_io_handle_t, AudioOutputDescriptor*> mOutputs;
// copy of mOutputs before setDeviceConnectionState() opens new outputs
// reset to mOutputs when updateDevicesAndOutputs() is called.
DefaultKeyedVector<audio_io_handle_t, AudioOutputDescriptor*> mPreviousOutputs;
// list of input descriptors currently opened
DefaultKeyedVector<audio_io_handle_t, AudioInputDescriptor*> mInputs;
audio_devices_t mAvailableOutputDevices; // bit field of all available output devices
audio_devices_t mAvailableInputDevices; // bit field of all available input devices
// without AUDIO_DEVICE_BIT_IN to allow direct bit
// field comparisons
int mPhoneState; // current phone state
AudioSystem::forced_config
mForceUse[AudioSystem::NUM_FORCE_USE]; // current forced use configuration
StreamDescriptor
mStreams[AudioSystem::NUM_STREAM_TYPES]; // stream descriptors for volume control
String8 mA2dpDeviceAddress; // A2DP device MAC address
String8 mScoDeviceAddress; // SCO device MAC address
String8 mUsbOutCardAndDevice; // USB audio ALSA card and device numbers:
// card=<card_number>;device=<><device_number>
bool mLimitRingtoneVolume; // limit ringtone volume to music volume if headset connected
audio_devices_t mDeviceForStrategy[NUM_STRATEGIES];
float mLastVoiceVolume; // last voice volume value sent to audio HAL
// Maximum CPU load allocated to audio effects in 0.1 MIPS (ARMv5TE, 0 WS memory) units
static const uint32_t MAX_EFFECTS_CPU_LOAD = 1000;
// Maximum memory allocated to audio effects in KB
static const uint32_t MAX_EFFECTS_MEMORY = 512;
uint32_t mTotalEffectsCpuLoad; // current CPU load used by effects
uint32_t mTotalEffectsMemory; // current memory used by effects
KeyedVector<int, EffectDescriptor*> mEffects; // list of registered audio effects
bool mA2dpSuspended; // true if A2DP output is suspended
bool mHasA2dp; // true on platforms with support for bluetooth A2DP
bool mHasUsb; // true on platforms with support for USB audio
bool mHasRemoteSubmix; // true on platforms with support for remote presentation of a submix
audio_devices_t mAttachedOutputDevices; // output devices always available on the platform
audio_devices_t mDefaultOutputDevice; // output device selected by default at boot time
// (must be in mAttachedOutputDevices)
bool mSpeakerDrcEnabled; // true on devices that use DRC on the DEVICE_CATEGORY_SPEAKER path
// to boost soft sounds, used to adjust volume curves accordingly
Vector<HwModule*> mHwModules;
#ifdef AUDIO_POLICY_TEST
Mutex mLock;
Condition mWaitWorkCV;
int mCurOutput;
bool mDirectOutput;
audio_io_handle_t mTestOutputs[NUM_TEST_OUTPUTS];
int mTestInput;
uint32_t mTestDevice;
uint32_t mTestSamplingRate;
uint32_t mTestFormat;
uint32_t mTestChannels;
uint32_t mTestLatencyMs;
#endif // AUDIO_POLICY_TEST
private:
static float volIndexToAmpl(audio_devices_t device, const StreamDescriptor& streamDesc,
int indexInUi);
// updates device caching and output for streams that can influence the
// routing of notifications
void handleNotificationRoutingForStream(AudioSystem::stream_type stream);
static bool isVirtualInputDevice(audio_devices_t device);
};
}; // namespace android_audio_legacy

358
wifi/1.6/default/hal_legacy/AudioSystemLegacy.h
View File

@@ -1,358 +0,0 @@
/*
* Copyright (C) 2008 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 ANDROID_AUDIOSYSTEM_LEGACY_H_
#define ANDROID_AUDIOSYSTEM_LEGACY_H_
#include <cutils/bitops.h>
#include <media/AudioParameter.h>
#include <utils/Errors.h>
#include <system/audio.h>
#include <system/audio_policy.h>
namespace android_audio_legacy {
using android::AudioParameter;
using android::status_t;
enum {
OK = android::OK,
NO_ERROR = android::NO_ERROR,
UNKNOWN_ERROR = android::UNKNOWN_ERROR,
NO_MEMORY = android::NO_MEMORY,
INVALID_OPERATION = android::INVALID_OPERATION,
BAD_VALUE = android::BAD_VALUE,
BAD_TYPE = android::BAD_TYPE,
NAME_NOT_FOUND = android::NAME_NOT_FOUND,
PERMISSION_DENIED = android::PERMISSION_DENIED,
NO_INIT = android::NO_INIT,
ALREADY_EXISTS = android::ALREADY_EXISTS,
DEAD_OBJECT = android::DEAD_OBJECT,
FAILED_TRANSACTION = android::FAILED_TRANSACTION,
BAD_INDEX = android::BAD_INDEX,
NOT_ENOUGH_DATA = android::NOT_ENOUGH_DATA,
WOULD_BLOCK = android::WOULD_BLOCK,
TIMED_OUT = android::TIMED_OUT,
UNKNOWN_TRANSACTION = android::UNKNOWN_TRANSACTION,
};
enum audio_source {
AUDIO_SOURCE_DEFAULT = 0,
AUDIO_SOURCE_MIC = 1,
AUDIO_SOURCE_VOICE_UPLINK = 2,
AUDIO_SOURCE_VOICE_DOWNLINK = 3,
AUDIO_SOURCE_VOICE_CALL = 4,
AUDIO_SOURCE_CAMCORDER = 5,
AUDIO_SOURCE_VOICE_RECOGNITION = 6,
AUDIO_SOURCE_VOICE_COMMUNICATION = 7,
AUDIO_SOURCE_MAX = AUDIO_SOURCE_VOICE_COMMUNICATION,
AUDIO_SOURCE_LIST_END // must be last - used to validate audio source type
};
class AudioSystem {
public:
#if 1
enum stream_type {
DEFAULT = -1,
VOICE_CALL = 0,
SYSTEM = 1,
RING = 2,
MUSIC = 3,
ALARM = 4,
NOTIFICATION = 5,
BLUETOOTH_SCO = 6,
ENFORCED_AUDIBLE = 7, // Sounds that cannot be muted by user and must be routed to speaker
DTMF = 8,
TTS = 9,
NUM_STREAM_TYPES
};
// Audio sub formats (see AudioSystem::audio_format).
enum pcm_sub_format {
PCM_SUB_16_BIT = 0x1, // must be 1 for backward compatibility
PCM_SUB_8_BIT = 0x2, // must be 2 for backward compatibility
};
enum audio_sessions {
SESSION_OUTPUT_STAGE = AUDIO_SESSION_OUTPUT_STAGE,
SESSION_OUTPUT_MIX = AUDIO_SESSION_OUTPUT_MIX,
};
// MP3 sub format field definition : can use 11 LSBs in the same way as MP3 frame header to
// specify bit rate, stereo mode, version...
enum mp3_sub_format {
// TODO
};
// AMR NB/WB sub format field definition: specify frame block interleaving, bandwidth efficient
// or octet aligned, encoding mode for recording...
enum amr_sub_format {
// TODO
};
// AAC sub format field definition: specify profile or bitrate for recording...
enum aac_sub_format {
// TODO
};
// VORBIS sub format field definition: specify quality for recording...
enum vorbis_sub_format {
// TODO
};
// Audio format consists in a main format field (upper 8 bits) and a sub format field (lower 24
// bits). The main format indicates the main codec type. The sub format field indicates options
// and parameters for each format. The sub format is mainly used for record to indicate for
// instance the requested bitrate or profile. It can also be used for certain formats to give
// informations not present in the encoded audio stream (e.g. octet alignement for AMR).
enum audio_format {
INVALID_FORMAT = -1,
FORMAT_DEFAULT = 0,
PCM = 0x00000000, // must be 0 for backward compatibility
MP3 = 0x01000000,
AMR_NB = 0x02000000,
AMR_WB = 0x03000000,
AAC = 0x04000000,
HE_AAC_V1 = 0x05000000,
HE_AAC_V2 = 0x06000000,
VORBIS = 0x07000000,
MAIN_FORMAT_MASK = 0xFF000000,
SUB_FORMAT_MASK = 0x00FFFFFF,
// Aliases
PCM_16_BIT = (PCM | PCM_SUB_16_BIT),
PCM_8_BIT = (PCM | PCM_SUB_8_BIT)
};
enum audio_channels {
// output channels
CHANNEL_OUT_FRONT_LEFT = 0x1,
CHANNEL_OUT_FRONT_RIGHT = 0x2,
CHANNEL_OUT_FRONT_CENTER = 0x4,
CHANNEL_OUT_LOW_FREQUENCY = 0x8,
CHANNEL_OUT_BACK_LEFT = 0x10,
CHANNEL_OUT_BACK_RIGHT = 0x20,
CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40,
CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80,
CHANNEL_OUT_BACK_CENTER = 0x100,
CHANNEL_OUT_SIDE_LEFT = 0x200,
CHANNEL_OUT_SIDE_RIGHT = 0x400,
CHANNEL_OUT_TOP_CENTER = 0x800,
CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000,
CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000,
CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000,
CHANNEL_OUT_TOP_BACK_LEFT = 0x8000,
CHANNEL_OUT_TOP_BACK_CENTER = 0x10000,
CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000,
CHANNEL_OUT_MONO = CHANNEL_OUT_FRONT_LEFT,
CHANNEL_OUT_STEREO = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT),
CHANNEL_OUT_QUAD = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
CHANNEL_OUT_SURROUND = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_BACK_CENTER),
CHANNEL_OUT_5POINT1 =
(CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | CHANNEL_OUT_FRONT_CENTER |
CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
// matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND definition for 7.1
CHANNEL_OUT_7POINT1 =
(CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | CHANNEL_OUT_FRONT_CENTER |
CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT |
CHANNEL_OUT_SIDE_LEFT | CHANNEL_OUT_SIDE_RIGHT),
CHANNEL_OUT_ALL =
(CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | CHANNEL_OUT_FRONT_CENTER |
CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT |
CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER |
CHANNEL_OUT_BACK_CENTER | CHANNEL_OUT_SIDE_LEFT | CHANNEL_OUT_SIDE_RIGHT |
CHANNEL_OUT_TOP_CENTER | CHANNEL_OUT_TOP_FRONT_LEFT |
CHANNEL_OUT_TOP_FRONT_CENTER | CHANNEL_OUT_TOP_FRONT_RIGHT |
CHANNEL_OUT_TOP_BACK_LEFT | CHANNEL_OUT_TOP_BACK_CENTER |
CHANNEL_OUT_TOP_BACK_RIGHT),
// input channels
CHANNEL_IN_LEFT = 0x4,
CHANNEL_IN_RIGHT = 0x8,
CHANNEL_IN_FRONT = 0x10,
CHANNEL_IN_BACK = 0x20,
CHANNEL_IN_LEFT_PROCESSED = 0x40,
CHANNEL_IN_RIGHT_PROCESSED = 0x80,
CHANNEL_IN_FRONT_PROCESSED = 0x100,
CHANNEL_IN_BACK_PROCESSED = 0x200,
CHANNEL_IN_PRESSURE = 0x400,
CHANNEL_IN_X_AXIS = 0x800,
CHANNEL_IN_Y_AXIS = 0x1000,
CHANNEL_IN_Z_AXIS = 0x2000,
CHANNEL_IN_VOICE_UPLINK = 0x4000,
CHANNEL_IN_VOICE_DNLINK = 0x8000,
CHANNEL_IN_MONO = CHANNEL_IN_FRONT,
CHANNEL_IN_STEREO = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT),
CHANNEL_IN_ALL = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT | CHANNEL_IN_FRONT | CHANNEL_IN_BACK |
CHANNEL_IN_LEFT_PROCESSED | CHANNEL_IN_RIGHT_PROCESSED |
CHANNEL_IN_FRONT_PROCESSED | CHANNEL_IN_BACK_PROCESSED |
CHANNEL_IN_PRESSURE | CHANNEL_IN_X_AXIS | CHANNEL_IN_Y_AXIS |
CHANNEL_IN_Z_AXIS | CHANNEL_IN_VOICE_UPLINK | CHANNEL_IN_VOICE_DNLINK)
};
enum audio_mode {
MODE_INVALID = -2,
MODE_CURRENT = -1,
MODE_NORMAL = 0,
MODE_RINGTONE,
MODE_IN_CALL,
MODE_IN_COMMUNICATION,
NUM_MODES // not a valid entry, denotes end-of-list
};
enum audio_in_acoustics {
AGC_ENABLE = 0x0001,
AGC_DISABLE = 0,
NS_ENABLE = 0x0002,
NS_DISABLE = 0,
TX_IIR_ENABLE = 0x0004,
TX_DISABLE = 0
};
// DO NOT USE: the "audio_devices" enumeration below is obsolete, use type "audio_devices_t" and
// audio device enumeration from system/audio.h instead.
enum audio_devices {
// output devices
DEVICE_OUT_EARPIECE = 0x1,
DEVICE_OUT_SPEAKER = 0x2,
DEVICE_OUT_WIRED_HEADSET = 0x4,
DEVICE_OUT_WIRED_HEADPHONE = 0x8,
DEVICE_OUT_BLUETOOTH_SCO = 0x10,
DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
DEVICE_OUT_AUX_DIGITAL = 0x400,
DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800,
DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000,
DEVICE_OUT_DEFAULT = 0x8000,
DEVICE_OUT_ALL =
(DEVICE_OUT_EARPIECE | DEVICE_OUT_SPEAKER | DEVICE_OUT_WIRED_HEADSET |
DEVICE_OUT_WIRED_HEADPHONE | DEVICE_OUT_BLUETOOTH_SCO |
DEVICE_OUT_BLUETOOTH_SCO_HEADSET | DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER | DEVICE_OUT_AUX_DIGITAL |
DEVICE_OUT_ANLG_DOCK_HEADSET | DEVICE_OUT_DGTL_DOCK_HEADSET | DEVICE_OUT_DEFAULT),
DEVICE_OUT_ALL_A2DP = (DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
// input devices
DEVICE_IN_COMMUNICATION = 0x10000,
DEVICE_IN_AMBIENT = 0x20000,
DEVICE_IN_BUILTIN_MIC = 0x40000,
DEVICE_IN_BLUETOOTH_SCO_HEADSET = 0x80000,
DEVICE_IN_WIRED_HEADSET = 0x100000,
DEVICE_IN_AUX_DIGITAL = 0x200000,
DEVICE_IN_VOICE_CALL = 0x400000,
DEVICE_IN_BACK_MIC = 0x800000,
DEVICE_IN_DEFAULT = 0x80000000,
DEVICE_IN_ALL =
(DEVICE_IN_COMMUNICATION | DEVICE_IN_AMBIENT | DEVICE_IN_BUILTIN_MIC |
DEVICE_IN_BLUETOOTH_SCO_HEADSET | DEVICE_IN_WIRED_HEADSET | DEVICE_IN_AUX_DIGITAL |
DEVICE_IN_VOICE_CALL | DEVICE_IN_BACK_MIC | DEVICE_IN_DEFAULT)
};
// request to open a direct output with getOutput() (by opposition to sharing an output with
// other AudioTracks)
enum output_flags { OUTPUT_FLAG_INDIRECT = 0x0, OUTPUT_FLAG_DIRECT = 0x1 };
// device categories used for setForceUse()
enum forced_config {
FORCE_NONE,
FORCE_SPEAKER,
FORCE_HEADPHONES,
FORCE_BT_SCO,
FORCE_BT_A2DP,
FORCE_WIRED_ACCESSORY,
FORCE_BT_CAR_DOCK,
FORCE_BT_DESK_DOCK,
FORCE_ANALOG_DOCK,
FORCE_DIGITAL_DOCK,
FORCE_NO_BT_A2DP,
FORCE_SYSTEM_ENFORCED,
NUM_FORCE_CONFIG,
FORCE_DEFAULT = FORCE_NONE
};
// usages used for setForceUse()
enum force_use {
FOR_COMMUNICATION,
FOR_MEDIA,
FOR_RECORD,
FOR_DOCK,
FOR_SYSTEM,
NUM_FORCE_USE
};
//
// AudioPolicyService interface
//
// device connection states used for setDeviceConnectionState()
enum device_connection_state {
DEVICE_STATE_UNAVAILABLE,
DEVICE_STATE_AVAILABLE,
NUM_DEVICE_STATES
};
#endif
static uint32_t popCount(uint32_t u) { return popcount(u); }
#if 1
static bool isOutputDevice(audio_devices device) {
if ((popcount(device) == 1) && ((device & ~DEVICE_OUT_ALL) == 0))
return true;
else
return false;
}
static bool isInputDevice(audio_devices device) {
if ((popcount(device) == 1) && ((device & ~DEVICE_IN_ALL) == 0))
return true;
else
return false;
}
static bool isA2dpDevice(audio_devices device) {
return audio_is_a2dp_device((audio_devices_t)device);
}
static bool isBluetoothScoDevice(audio_devices device) {
return audio_is_bluetooth_sco_device((audio_devices_t)device);
}
static bool isValidFormat(uint32_t format) {
return audio_is_valid_format((audio_format_t)format);
}
static bool isLinearPCM(uint32_t format) { return audio_is_linear_pcm((audio_format_t)format); }
static bool isOutputChannel(audio_channel_mask_t channel) {
return audio_is_output_channel(channel);
}
static bool isInputChannel(audio_channel_mask_t channel) {
return audio_is_input_channel(channel);
}
#endif
};
}; // namespace android_audio_legacy
#endif // ANDROID_AUDIOSYSTEM_LEGACY_H_

65
wifi/1.6/default/hal_legacy/IMountService.h
View File

@@ -1,65 +0,0 @@
/*
* Copyright (C) 2007 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 ANDROID_HARDWARE_IMOUNTSERVICE_H
#define ANDROID_HARDWARE_IMOUNTSERVICE_H
#include <binder/IInterface.h>
#include <utils/String16.h>
namespace android {
// ----------------------------------------------------------------------
class IMountService : public IInterface {
public:
static const int OperationSucceeded = 0;
static const int OperationFailedInternalError = -1;
static const int OperationFailedNoMedia = -2;
static const int OperationFailedMediaBlank = -3;
static const int OperationFailedMediaCorrupt = -4;
static const int OperationFailedVolumeNotMounted = -5;
public:
DECLARE_META_INTERFACE(MountService);
virtual void getShareMethodList() = 0;
virtual bool getShareMethodAvailable(String16 method) = 0;
virtual int shareVolume(String16 path, String16 method) = 0;
virtual int unshareVolume(String16 path, String16 method) = 0;
virtual bool getVolumeShared(String16 path, String16 method) = 0;
virtual int mountVolume(String16 path) = 0;
virtual int unmountVolume(String16 path) = 0;
virtual int formatVolume(String16 path) = 0;
virtual String16 getVolumeState(String16 mountPoint) = 0;
virtual int createSecureContainer(String16 id, int sizeMb, String16 fstype, String16 key,
int ownerUid) = 0;
virtual int finalizeSecureContainer(String16 id) = 0;
virtual int destroySecureContainer(String16 id) = 0;
virtual int mountSecureContainer(String16 id, String16 key, int ownerUid) = 0;
virtual int unmountSecureContainer(String16 id) = 0;
virtual int renameSecureContainer(String16 oldId, String16 newId) = 0;
virtual String16 getSecureContainerPath(String16 id) = 0;
virtual void getSecureContainerList() = 0;
virtual void shutdown() = 0;
};
// ----------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_HARDWARE_IMOUNTSERVICE_H

54
wifi/1.6/default/hal_legacy/audio_policy_conf.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright (C) 2012 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 ANDROID_AUDIO_POLICY_CONF_H
#define ANDROID_AUDIO_POLICY_CONF_H
/////////////////////////////////////////////////
// Definitions for audio policy configuration file (audio_policy.conf)
/////////////////////////////////////////////////
#define AUDIO_HARDWARE_MODULE_ID_MAX_LEN 32
#define AUDIO_POLICY_CONFIG_FILE "/system/etc/audio_policy.conf"
#define AUDIO_POLICY_VENDOR_CONFIG_FILE "/vendor/etc/audio_policy.conf"
// global configuration
#define GLOBAL_CONFIG_TAG "global_configuration"
#define ATTACHED_OUTPUT_DEVICES_TAG "attached_output_devices"
#define DEFAULT_OUTPUT_DEVICE_TAG "default_output_device"
#define ATTACHED_INPUT_DEVICES_TAG "attached_input_devices"
#define SPEAKER_DRC_ENABLED_TAG "speaker_drc_enabled"
// hw modules descriptions
#define AUDIO_HW_MODULE_TAG "audio_hw_modules"
#define OUTPUTS_TAG "outputs"
#define INPUTS_TAG "inputs"
#define SAMPLING_RATES_TAG "sampling_rates"
#define FORMATS_TAG "formats"
#define CHANNELS_TAG "channel_masks"
#define DEVICES_TAG "devices"
#define FLAGS_TAG "flags"
#define DYNAMIC_VALUE_TAG \
"dynamic" // special value for "channel_masks", "sampling_rates" and
// "formats" in outputs descriptors indicating that supported
// values should be queried after opening the output.
#endif // ANDROID_AUDIO_POLICY_CONF_H

427
wifi/1.6/default/hal_legacy/gscan.h
View File

@@ -1,427 +0,0 @@
#include "wifi_hal.h"
#ifndef __WIFI_HAL_GSCAN_H__
#define __WIFI_HAL_GSCAN_H__
// Define static_assert() unless already defined by compiler.
#ifndef __has_feature
#define __has_feature(__x) 0
#endif
#if !(__has_feature(cxx_static_assert)) && !defined(static_assert)
#define static_assert(__b, __m) \
extern int compile_time_assert_failed[(__b) ? 1 : -1] __attribute__((unused));
#endif
/* AP Scans */
typedef enum {
WIFI_BAND_UNSPECIFIED,
WIFI_BAND_BG = 1, // 2.4 GHz
WIFI_BAND_A = 2, // 5 GHz without DFS
WIFI_BAND_A_DFS = 4, // 5 GHz DFS only
WIFI_BAND_A_WITH_DFS = 6, // 5 GHz with DFS
WIFI_BAND_ABG = 3, // 2.4 GHz + 5 GHz; no DFS
WIFI_BAND_ABG_WITH_DFS = 7, // 2.4 GHz + 5 GHz with DFS
} wifi_band;
#define MAX_CHANNELS 16
#define MAX_BUCKETS 16
#define MAX_HOTLIST_APS 128
#define MAX_SIGNIFICANT_CHANGE_APS 64
#define MAX_EPNO_NETWORKS 64
#define MAX_HOTLIST_SSID 8
#define MAX_AP_CACHE_PER_SCAN 32
wifi_error wifi_get_valid_channels(wifi_interface_handle handle, int band, int max_channels,
wifi_channel* channels, int* num_channels);
typedef struct {
int max_scan_cache_size; // total space allocated for scan (in bytes)
int max_scan_buckets; // maximum number of channel buckets
int max_ap_cache_per_scan; // maximum number of APs that can be stored per scan
int max_rssi_sample_size; // number of RSSI samples used for averaging RSSI
int max_scan_reporting_threshold; // max possible report_threshold as described
// in wifi_scan_cmd_params
int max_hotlist_bssids; // maximum number of entries for hotlist BSSIDs
int max_hotlist_ssids; // maximum number of entries for hotlist SSIDs
int max_significant_wifi_change_aps; // maximum number of entries for
// significant wifi change APs
int max_bssid_history_entries; // number of BSSID/RSSI entries that device can hold
int max_number_epno_networks; // max number of epno entries
int max_number_epno_networks_by_ssid; // max number of epno entries if ssid is specified,
// that is, epno entries for which an exact match is
// required, or entries corresponding to hidden ssids
int max_number_of_white_listed_ssid; // max number of white listed SSIDs, M target is 2 to 4
} wifi_gscan_capabilities;
wifi_error wifi_get_gscan_capabilities(wifi_interface_handle handle,
wifi_gscan_capabilities* capabilities);
typedef enum {
WIFI_SCAN_RESULTS_AVAILABLE, // reported when REPORT_EVENTS_EACH_SCAN is set and a scan
// completes. WIFI_SCAN_THRESHOLD_NUM_SCANS or
// WIFI_SCAN_THRESHOLD_PERCENT can be reported instead if the
// reason for the event is available; however, at most one of
// these events should be reported per scan. If there are
// multiple buckets that were scanned this period and one has the
// EACH_SCAN flag set then this event should be prefered.
WIFI_SCAN_THRESHOLD_NUM_SCANS, // can be reported when REPORT_EVENTS_EACH_SCAN is not set and
// report_threshold_num_scans is reached.
WIFI_SCAN_THRESHOLD_PERCENT, // can be reported when REPORT_EVENTS_EACH_SCAN is not set and
// report_threshold_percent is reached.
WIFI_SCAN_FAILED, // reported when currently executing gscans have failed.
// start_gscan will need to be called again in order to continue
// scanning. This is intended to indicate abnormal scan
// terminations (not those as a result of stop_gscan).
} wifi_scan_event;
/* Format of information elements found in the beacon */
typedef struct {
byte id; // element identifier
byte len; // number of bytes to follow
byte data[];
} wifi_information_element;
typedef struct {
wifi_timestamp ts; // time since boot (in microsecond) when the result was
// retrieved
char ssid[32 + 1]; // null terminated
mac_addr bssid;
wifi_channel channel; // channel frequency in MHz
wifi_rssi rssi; // in db
wifi_timespan rtt; // in nanoseconds
wifi_timespan rtt_sd; // standard deviation in rtt
unsigned short beacon_period; // period advertised in the beacon
unsigned short capability; // capabilities advertised in the beacon
unsigned int ie_length; // size of the ie_data blob
char ie_data[1]; // blob of all the information elements found in the
// beacon; this data should be a packed list of
// wifi_information_element objects, one after the other.
// other fields
} wifi_scan_result;
static_assert(
MAX_BUCKETS <= 8 * sizeof(unsigned),
"The buckets_scanned bitset is represented by an unsigned int and cannot support this many "
"buckets on this platform.");
typedef struct {
/* reported when each probe response is received, if report_events
* enabled in wifi_scan_cmd_params. buckets_scanned is a bitset of the
* buckets that are currently being scanned. See the buckets_scanned field
* in the wifi_cached_scan_results struct for more details.
*/
void (*on_full_scan_result)(wifi_request_id id, wifi_scan_result* result,
unsigned buckets_scanned);
/* indicates progress of scanning statemachine */
void (*on_scan_event)(wifi_request_id id, wifi_scan_event event);
} wifi_scan_result_handler;
typedef struct {
wifi_channel channel; // frequency
int dwellTimeMs; // dwell time hint
int passive; // 0 => active, 1 => passive scan; ignored for DFS
/* Add channel class */
} wifi_scan_channel_spec;
#define REPORT_EVENTS_EACH_SCAN (1 << 0)
#define REPORT_EVENTS_FULL_RESULTS (1 << 1)
#define REPORT_EVENTS_NO_BATCH (1 << 2)
typedef struct {
int bucket; // bucket index, 0 based
wifi_band band; // when UNSPECIFIED, use channel list
int period; // desired period, in millisecond; if this is too
// low, the firmware should choose to generate results as
// fast as it can instead of failing the command.
// for exponential backoff bucket this is the min_period
/* report_events semantics -
* This is a bit field; which defines following bits -
* REPORT_EVENTS_EACH_SCAN => report a scan completion event after scan. If this is not set
* then scan completion events should be reported if
* report_threshold_percent or report_threshold_num_scans is
* reached.
* REPORT_EVENTS_FULL_RESULTS => forward scan results (beacons/probe responses + IEs)
* in real time to HAL, in addition to completion events
* Note: To keep backward compatibility, fire completion
* events regardless of REPORT_EVENTS_EACH_SCAN.
* REPORT_EVENTS_NO_BATCH => controls if scans for this bucket should be placed in the
* history buffer
*/
byte report_events;
int max_period; // if max_period is non zero or different than period, then this bucket is
// an exponential backoff bucket and the scan period will grow exponentially
// as per formula: actual_period(N) = period * (base ^ (N/step_count))
// to a maximum period of max_period
int base; // for exponential back off bucket: multiplier: new_period=old_period*base
int step_count; // for exponential back off bucket, number of scans to perform for a given
// period
int num_channels;
// channels to scan; these may include DFS channels
// Note that a given channel may appear in multiple buckets
wifi_scan_channel_spec channels[MAX_CHANNELS];
} wifi_scan_bucket_spec;
typedef struct {
int base_period; // base timer period in ms
int max_ap_per_scan; // number of access points to store in each scan entry in
// the BSSID/RSSI history buffer (keep the highest RSSI
// access points)
int report_threshold_percent; // in %, when scan buffer is this much full, wake up apps
// processor
int report_threshold_num_scans; // in number of scans, wake up AP after these many scans
int num_buckets;
wifi_scan_bucket_spec buckets[MAX_BUCKETS];
} wifi_scan_cmd_params;
/*
* Start periodic GSCAN
* When this is called all requested buckets should be scanned, starting the beginning of the cycle
*
* For example:
* If there are two buckets specified
* - Bucket 1: period=10s
* - Bucket 2: period=20s
* - Bucket 3: period=30s
* Then the following scans should occur
* - t=0 buckets 1, 2, and 3 are scanned
* - t=10 bucket 1 is scanned
* - t=20 bucket 1 and 2 are scanned
* - t=30 bucket 1 and 3 are scanned
* - t=40 bucket 1 and 2 are scanned
* - t=50 bucket 1 is scanned
* - t=60 buckets 1, 2, and 3 are scanned
* - and the patter repeats
*
* If any scan does not occur or is incomplete (error, interrupted, etc) then a cached scan result
* should still be recorded with the WIFI_SCAN_FLAG_INTERRUPTED flag set.
*/
wifi_error wifi_start_gscan(wifi_request_id id, wifi_interface_handle iface,
wifi_scan_cmd_params params, wifi_scan_result_handler handler);
/* Stop periodic GSCAN */
wifi_error wifi_stop_gscan(wifi_request_id id, wifi_interface_handle iface);
typedef enum {
WIFI_SCAN_FLAG_INTERRUPTED = 1 // Indicates that scan results are not complete because
// probes were not sent on some channels
} wifi_scan_flags;
/* Get the GSCAN cached scan results */
typedef struct {
int scan_id; // a unique identifier for the scan unit
int flags; // a bitmask with additional
// information about scan.
unsigned buckets_scanned; // a bitset of the buckets that were scanned.
// for example a value of 13 (0b1101) would
// indicate that buckets 0, 2 and 3 were
// scanned to produce this list of results.
// should be set to 0 if this information is
// not available.
int num_results; // number of bssids retrieved by the scan
wifi_scan_result results[MAX_AP_CACHE_PER_SCAN]; // scan results - one for each bssid
} wifi_cached_scan_results;
wifi_error wifi_get_cached_gscan_results(wifi_interface_handle iface, byte flush, int max,
wifi_cached_scan_results* results, int* num);
/* BSSID Hotlist */
typedef struct {
void (*on_hotlist_ap_found)(wifi_request_id id, unsigned num_results,
wifi_scan_result* results);
void (*on_hotlist_ap_lost)(wifi_request_id id, unsigned num_results, wifi_scan_result* results);
} wifi_hotlist_ap_found_handler;
typedef struct {
mac_addr bssid; // AP BSSID
wifi_rssi low; // low threshold
wifi_rssi high; // high threshold
} ap_threshold_param;
typedef struct {
int lost_ap_sample_size;
int num_bssid; // number of hotlist APs
ap_threshold_param ap[MAX_HOTLIST_APS]; // hotlist APs
} wifi_bssid_hotlist_params;
/* Set the BSSID Hotlist */
wifi_error wifi_set_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface,
wifi_bssid_hotlist_params params,
wifi_hotlist_ap_found_handler handler);
/* Clear the BSSID Hotlist */
wifi_error wifi_reset_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface);
/* SSID Hotlist */
typedef struct {
void (*on_hotlist_ssid_found)(wifi_request_id id, unsigned num_results,
wifi_scan_result* results);
void (*on_hotlist_ssid_lost)(wifi_request_id id, unsigned num_results,
wifi_scan_result* results);
} wifi_hotlist_ssid_handler;
typedef struct {
char ssid[32 + 1]; // SSID
wifi_band band; // band for this set of threshold params
wifi_rssi low; // low threshold
wifi_rssi high; // high threshold
} ssid_threshold_param;
typedef struct {
int lost_ssid_sample_size;
int num_ssid; // number of hotlist SSIDs
ssid_threshold_param ssid[MAX_HOTLIST_SSID]; // hotlist SSIDs
} wifi_ssid_hotlist_params;
/* Significant wifi change */
typedef struct {
mac_addr bssid; // BSSID
wifi_channel channel; // channel frequency in MHz
int num_rssi; // number of rssi samples
wifi_rssi rssi[]; // RSSI history in db
} wifi_significant_change_result;
typedef struct {
void (*on_significant_change)(wifi_request_id id, unsigned num_results,
wifi_significant_change_result** results);
} wifi_significant_change_handler;
// The sample size parameters in the wifi_significant_change_params structure
// represent the number of occurence of a g-scan where the BSSID was seen and RSSI was
// collected for that BSSID, or, the BSSID was expected to be seen and didn't.
// for instance: lost_ap_sample_size : number of time a g-scan was performed on the
// channel the BSSID was seen last, and the BSSID was not seen during those g-scans
typedef struct {
int rssi_sample_size; // number of samples for averaging RSSI
int lost_ap_sample_size; // number of samples to confirm AP loss
int min_breaching; // number of APs breaching threshold
int num_bssid; // max 64
ap_threshold_param ap[MAX_SIGNIFICANT_CHANGE_APS];
} wifi_significant_change_params;
/* Set the Signifcant AP change list */
wifi_error wifi_set_significant_change_handler(wifi_request_id id, wifi_interface_handle iface,
wifi_significant_change_params params,
wifi_significant_change_handler handler);
/* Clear the Signifcant AP change list */
wifi_error wifi_reset_significant_change_handler(wifi_request_id id, wifi_interface_handle iface);
/* Random MAC OUI for PNO */
wifi_error wifi_set_scanning_mac_oui(wifi_interface_handle handle, oui scan_oui);
// Enhanced PNO:
// Enhanced PNO feature is expected to be enabled all of the time (e.g. screen lit) and may thus
// require firmware to store a large number of networks, covering the whole list of known networks.
// Therefore, it is acceptable for firmware to store a crc24, crc32 or other short hash of the SSID,
// such that a low but non-zero probability of collision exist. With that scheme it should be
// possible for firmware to keep an entry as small as 4 bytes for each pno network.
// For instance, a firmware pn0 entry can be implemented in the form of:
// PNO ENTRY = crc24(3 bytes) | flags>>3 (5 bits) | auth flags(3 bits)
//
// No scans should be automatically performed by the chip. Instead all scan results from gscan
// should be scored and the wifi_epno_handler on_network_found callback should be called with
// the scan results.
//
// A PNO network shall be reported once, that is, once a network is reported by firmware
// its entry shall be marked as "done" until framework calls wifi_set_epno_list again.
// Calling wifi_set_epno_list shall reset the "done" status of pno networks in firmware.
//
// A network should only be considered found if its RSSI is above the minimum RSSI for its
// frequency range (min5GHz_rssi and min24GHz_rssi for 5GHz and 2.4GHz networks respectively).
// When disconnected the list of scan results should be returned if any network is found.
// When connected the scan results shall be reported only if the score of any network in the scan
// is greater than that of the currently connected BSSID.
//
// The FW should calculate the score of all the candidates (including currently connected one)
// with following equation:
// RSSI score = (RSSI + 85) * 4;
// If RSSI score > initial_score_max , RSSI score = initial_score_max;
// final score = RSSI score
// + current_connection_bonus (if currently connected BSSID)
// + same_network_bonus (if network has SAME_NETWORK flag)
// + secure_bonus (if the network is not open)
// + band5GHz_bonus (if BSSID is on 5G)
// If there is a BSSID’s score > current BSSID’s score, then report the cached scan results
// at the end of the scan (excluding the ones on blacklist) to the upper layer.
// Additionally, all BSSIDs that are in the BSSID blacklist should be ignored by Enhanced PNO
// Whether directed scan needs to be performed (for hidden SSIDs)
#define WIFI_PNO_FLAG_DIRECTED_SCAN (1 << 0)
// Whether PNO event shall be triggered if the network is found on A band
#define WIFI_PNO_FLAG_A_BAND (1 << 1)
// Whether PNO event shall be triggered if the network is found on G band
#define WIFI_PNO_FLAG_G_BAND (1 << 2)
// Whether strict matching is required
// If required then the firmware must store the network's SSID and not just a hash
#define WIFI_PNO_FLAG_STRICT_MATCH (1 << 3)
// If this SSID should be considered the same network as the currently connected one for scoring
#define WIFI_PNO_FLAG_SAME_NETWORK (1 << 4)
// Code for matching the beacon AUTH IE - additional codes TBD
#define WIFI_PNO_AUTH_CODE_OPEN (1 << 0) // open
#define WIFI_PNO_AUTH_CODE_PSK (1 << 1) // WPA_PSK or WPA2PSK
#define WIFI_PNO_AUTH_CODE_EAPOL (1 << 2) // any EAPOL
typedef struct {
char ssid[32 + 1]; // null terminated
byte flags; // WIFI_PNO_FLAG_XXX
byte auth_bit_field; // auth bit field for matching WPA IE
} wifi_epno_network;
/* ePNO Parameters */
typedef struct {
int min5GHz_rssi; // minimum 5GHz RSSI for a BSSID to be considered
int min24GHz_rssi; // minimum 2.4GHz RSSI for a BSSID to be considered
int initial_score_max; // the maximum score that a network can have before bonuses
int current_connection_bonus; // only report when there is a network's score this much higher
// than the current connection.
int same_network_bonus; // score bonus for all networks with the same network flag
int secure_bonus; // score bonus for networks that are not open
int band5GHz_bonus; // 5GHz RSSI score bonus (applied to all 5GHz networks)
int num_networks; // number of wifi_epno_network objects
wifi_epno_network networks[MAX_EPNO_NETWORKS]; // PNO networks
} wifi_epno_params;
typedef struct {
// on results
void (*on_network_found)(wifi_request_id id, unsigned num_results, wifi_scan_result* results);
} wifi_epno_handler;
/* Set the ePNO list - enable ePNO with the given parameters */
wifi_error wifi_set_epno_list(wifi_request_id id, wifi_interface_handle iface,
const wifi_epno_params* epno_params, wifi_epno_handler handler);
/* Reset the ePNO list - no ePNO networks should be matched after this */
wifi_error wifi_reset_epno_list(wifi_request_id id, wifi_interface_handle iface);
typedef struct {
int id; // identifier of this network block, report this in event
char realm[256]; // null terminated UTF8 encoded realm, 0 if unspecified
int64_t roamingConsortiumIds[16]; // roaming consortium ids to match, 0s if unspecified
byte plmn[3]; // mcc/mnc combination as per rules, 0s if unspecified
} wifi_passpoint_network;
typedef struct {
void (*on_passpoint_network_found)(
wifi_request_id id,
int net_id, // network block identifier for the matched network
wifi_scan_result* result, // scan result, with channel and beacon information
int anqp_len, // length of ANQP blob
byte* anqp // ANQP data, in the information_element format
);
} wifi_passpoint_event_handler;
/* Sets a list for passpoint networks for PNO purposes; it should be matched
* against any passpoint networks (designated by Interworking element) found
* during regular PNO scan. */
wifi_error wifi_set_passpoint_list(wifi_request_id id, wifi_interface_handle iface, int num,
wifi_passpoint_network* networks,
wifi_passpoint_event_handler handler);
/* Reset passpoint network list - no Passpoint networks should be matched after this */
wifi_error wifi_reset_passpoint_list(wifi_request_id id, wifi_interface_handle iface);
#endif

285
wifi/1.6/default/hal_legacy/link_layer_stats.h
View File

@@ -1,285 +0,0 @@
#include "wifi_hal.h"
#ifndef __WIFI_HAL_STATS_H
#define __WIFI_HAL_STATS_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define STATS_MAJOR_VERSION 1
#define STATS_MINOR_VERSION 0
#define STATS_MICRO_VERSION 0
typedef enum {
WIFI_DISCONNECTED = 0,
WIFI_AUTHENTICATING = 1,
WIFI_ASSOCIATING = 2,
WIFI_ASSOCIATED = 3,
WIFI_EAPOL_STARTED = 4, // if done by firmware/driver
WIFI_EAPOL_COMPLETED = 5, // if done by firmware/driver
} wifi_connection_state;
typedef enum {
WIFI_ROAMING_IDLE = 0,
WIFI_ROAMING_ACTIVE = 1,
} wifi_roam_state;
typedef enum {
WIFI_INTERFACE_STA = 0,
WIFI_INTERFACE_SOFTAP = 1,
WIFI_INTERFACE_IBSS = 2,
WIFI_INTERFACE_P2P_CLIENT = 3,
WIFI_INTERFACE_P2P_GO = 4,
WIFI_INTERFACE_NAN = 5,
WIFI_INTERFACE_MESH = 6,
WIFI_INTERFACE_TDLS = 7,
WIFI_INTERFACE_UNKNOWN = -1
} wifi_interface_mode;
#define WIFI_CAPABILITY_QOS 0x00000001 // set for QOS association
#define WIFI_CAPABILITY_PROTECTED \
0x00000002 // set for protected association (802.11 beacon frame control protected bit set)
#define WIFI_CAPABILITY_INTERWORKING \
0x00000004 // set if 802.11 Extended Capabilities element interworking bit is set
#define WIFI_CAPABILITY_HS20 0x00000008 // set for HS20 association
#define WIFI_CAPABILITY_SSID_UTF8 \
0x00000010 // set is 802.11 Extended Capabilities element UTF-8 SSID bit is set
#define WIFI_CAPABILITY_COUNTRY 0x00000020 // set is 802.11 Country Element is present
typedef struct {
wifi_interface_mode mode; // interface mode
u8 mac_addr[6]; // interface mac address (self)
wifi_connection_state state; // connection state (valid for STA, CLI only)
wifi_roam_state roaming; // roaming state
u32 capabilities; // WIFI_CAPABILITY_XXX (self)
u8 ssid[33]; // null terminated SSID
u8 bssid[6]; // bssid
u8 ap_country_str[3]; // country string advertised by AP
u8 country_str[3]; // country string for this association
u8 time_slicing_duty_cycle_percent; // if this iface is being served using time slicing on a
// radio with one or more ifaces (i.e MCC), then the duty
// cycle assigned to this iface in %. If not using time
// slicing (i.e SCC or DBS), set to 100.
} wifi_interface_link_layer_info;
/* channel information */
typedef struct {
wifi_channel_width width; // channel width (20, 40, 80, 80+80, 160, 320)
wifi_channel center_freq; // primary 20 MHz channel
wifi_channel center_freq0; // center frequency (MHz) first segment
wifi_channel center_freq1; // center frequency (MHz) second segment
} wifi_channel_info;
/* wifi rate */
typedef struct {
u32 preamble : 3; // 0: OFDM, 1:CCK, 2:HT 3:VHT 4:HE 5:EHT 6..7 reserved
u32 nss : 2; // 0:1x1, 1:2x2, 3:3x3, 4:4x4
u32 bw : 3; // 0:20MHz, 1:40Mhz, 2:80Mhz, 3:160Mhz 4:320Mhz
u32 rateMcsIdx : 8; // OFDM/CCK rate code would be as per ieee std in the units of 0.5mbps
// HT/VHT/HE/EHT it would be mcs index
u32 reserved : 16; // reserved
u32 bitrate; // units of 100 Kbps
} wifi_rate;
/* channel statistics */
typedef struct {
wifi_channel_info channel; // channel
u32 on_time; // msecs the radio is awake (32 bits number accruing over time)
u32 cca_busy_time; // msecs the CCA register is busy (32 bits number accruing over time)
} wifi_channel_stat;
// Max number of tx power levels. The actual number vary per device and is specified by
// |num_tx_levels|
#define RADIO_STAT_MAX_TX_LEVELS 256
/* radio statistics */
typedef struct {
wifi_radio radio; // wifi radio (if multiple radio supported)
u32 on_time; // msecs the radio is awake (32 bits number accruing over time)
u32 tx_time; // msecs the radio is transmitting (32 bits number accruing over time)
u32 num_tx_levels; // number of radio transmit power levels
u32* tx_time_per_levels; // pointer to an array of radio transmit per power levels in
// msecs accured over time
u32 rx_time; // msecs the radio is in active receive (32 bits number accruing over time)
u32 on_time_scan; // msecs the radio is awake due to all scan (32 bits number accruing over
// time)
u32 on_time_nbd; // msecs the radio is awake due to NAN (32 bits number accruing over time)
u32 on_time_gscan; // msecs the radio is awake due to G?scan (32 bits number accruing over
// time)
u32 on_time_roam_scan; // msecs the radio is awake due to roam?scan (32 bits number accruing
// over time)
u32 on_time_pno_scan; // msecs the radio is awake due to PNO scan (32 bits number accruing over
// time)
u32 on_time_hs20; // msecs the radio is awake due to HS2.0 scans and GAS exchange (32 bits
// number accruing over time)
u32 num_channels; // number of channels
wifi_channel_stat channels[]; // channel statistics
} wifi_radio_stat;
/**
* Packet statistics reporting by firmware is performed on MPDU basi (i.e. counters increase by 1
* for each MPDU) As well, "data packet" in associated comments, shall be interpreted as 802.11 data
* packet, that is, 802.11 frame control subtype == 2 and excluding management and control frames.
*
* As an example, in the case of transmission of an MSDU fragmented in 16 MPDUs which are
* transmitted OTA in a 16 units long a-mpdu, for which a block ack is received with 5 bits set:
* tx_mpdu : shall increase by 5
* retries : shall increase by 16
* tx_ampdu : shall increase by 1
* data packet counters shall not increase regardless of the number of BAR potentially sent by
* device for this a-mpdu data packet counters shall not increase regardless of the number of BA
* received by device for this a-mpdu
*
* For each subsequent retransmission of the 11 remaining non ACK'ed mpdus
* (regardless of the fact that they are transmitted in a-mpdu or not)
* retries : shall increase by 1
*
* If no subsequent BA or ACK are received from AP, until packet lifetime expires for those 11
* packet that were not ACK'ed mpdu_lost : shall increase by 11
*/
/* per rate statistics */
typedef struct {
wifi_rate rate; // rate information
u32 tx_mpdu; // number of successfully transmitted data pkts (ACK rcvd)
u32 rx_mpdu; // number of received data pkts
u32 mpdu_lost; // number of data packet losses (no ACK)
u32 retries; // total number of data pkt retries
u32 retries_short; // number of short data pkt retries
u32 retries_long; // number of long data pkt retries
} wifi_rate_stat;
/* access categories */
typedef enum {
WIFI_AC_VO = 0,
WIFI_AC_VI = 1,
WIFI_AC_BE = 2,
WIFI_AC_BK = 3,
WIFI_AC_MAX = 4,
} wifi_traffic_ac;
/* wifi peer type */
typedef enum {
WIFI_PEER_STA,
WIFI_PEER_AP,
WIFI_PEER_P2P_GO,
WIFI_PEER_P2P_CLIENT,
WIFI_PEER_NAN,
WIFI_PEER_TDLS,
WIFI_PEER_INVALID,
} wifi_peer_type;
/* per peer statistics */
typedef struct bssload_info {
u16 sta_count; // station count
u16 chan_util; // channel utilization
u8 PAD[4];
} bssload_info_t;
typedef struct {
wifi_peer_type type; // peer type (AP, TDLS, GO etc.)
u8 peer_mac_address[6]; // mac address
u32 capabilities; // peer WIFI_CAPABILITY_XXX
bssload_info_t bssload; // STA count and CU
u32 num_rate; // number of rates
wifi_rate_stat rate_stats[]; // per rate statistics, number of entries = num_rate
} wifi_peer_info;
/* Per access category statistics */
typedef struct {
wifi_traffic_ac ac; // access category (VI, VO, BE, BK)
u32 tx_mpdu; // number of successfully transmitted unicast data pkts (ACK rcvd)
u32 rx_mpdu; // number of received unicast data packets
u32 tx_mcast; // number of succesfully transmitted multicast data packets
// STA case: implies ACK received from AP for the unicast packet in which mcast
// pkt was sent
u32 rx_mcast; // number of received multicast data packets
u32 rx_ampdu; // number of received unicast a-mpdus; support of this counter is optional
u32 tx_ampdu; // number of transmitted unicast a-mpdus; support of this counter is optional
u32 mpdu_lost; // number of data pkt losses (no ACK)
u32 retries; // total number of data pkt retries
u32 retries_short; // number of short data pkt retries
u32 retries_long; // number of long data pkt retries
u32 contention_time_min; // data pkt min contention time (usecs)
u32 contention_time_max; // data pkt max contention time (usecs)
u32 contention_time_avg; // data pkt avg contention time (usecs)
u32 contention_num_samples; // num of data pkts used for contention statistics
} wifi_wmm_ac_stat;
/* interface statistics */
typedef struct {
wifi_interface_handle iface; // wifi interface
wifi_interface_link_layer_info info; // current state of the interface
u32 beacon_rx; // access point beacon received count from connected AP
u64 average_tsf_offset; // average beacon offset encountered (beacon_TSF - TBTT)
// The average_tsf_offset field is used so as to calculate the
// typical beacon contention time on the channel as well may be
// used to debug beacon synchronization and related power consumption
// issue
u32 leaky_ap_detected; // indicate that this AP typically leaks packets beyond the driver guard
// time.
u32 leaky_ap_avg_num_frames_leaked; // average number of frame leaked by AP after frame with PM
// bit set was ACK'ed by AP
u32 leaky_ap_guard_time; // guard time currently in force (when implementing IEEE power
// management based on frame control PM bit), How long driver waits
// before shutting down the radio and after receiving an ACK for a
// data frame with PM bit set)
u32 mgmt_rx; // access point mgmt frames received count from connected AP (including Beacon)
u32 mgmt_action_rx; // action frames received count
u32 mgmt_action_tx; // action frames transmit count
wifi_rssi rssi_mgmt; // access Point Beacon and Management frames RSSI (averaged)
wifi_rssi rssi_data; // access Point Data Frames RSSI (averaged) from connected AP
wifi_rssi rssi_ack; // access Point ACK RSSI (averaged) from connected AP
wifi_wmm_ac_stat ac[WIFI_AC_MAX]; // per ac data packet statistics
u32 num_peers; // number of peers
wifi_peer_info peer_info[]; // per peer statistics
} wifi_iface_stat;
/* configuration params */
typedef struct {
u32 mpdu_size_threshold; // threshold to classify the pkts as short or long
// packet size < mpdu_size_threshold => short
u32 aggressive_statistics_gathering; // set for field debug mode. Driver should collect all
// statistics regardless of performance impact.
} wifi_link_layer_params;
/* API to trigger the link layer statistics collection.
Unless his API is invoked - link layer statistics will not be collected.
Radio statistics (once started) do not stop or get reset unless wifi_clear_link_stats is invoked
Interface statistics (once started) reset and start afresh after each connection */
wifi_error wifi_set_link_stats(wifi_interface_handle iface, wifi_link_layer_params params);
/* callback for reporting link layer stats */
typedef struct {
void (*on_link_stats_results)(wifi_request_id id, wifi_iface_stat* iface_stat, int num_radios,
wifi_radio_stat* radio_stat);
} wifi_stats_result_handler;
/* api to collect the link layer statistics for a given iface and all the radio stats */
wifi_error wifi_get_link_stats(wifi_request_id id, wifi_interface_handle iface,
wifi_stats_result_handler handler);
/* wifi statistics bitmap */
#define WIFI_STATS_RADIO 0x00000001 // all radio statistics
#define WIFI_STATS_RADIO_CCA 0x00000002 // cca_busy_time (within radio statistics)
#define WIFI_STATS_RADIO_CHANNELS 0x00000004 // all channel statistics (within radio statistics)
#define WIFI_STATS_RADIO_SCAN 0x00000008 // all scan statistics (within radio statistics)
#define WIFI_STATS_IFACE 0x00000010 // all interface statistics
#define WIFI_STATS_IFACE_TXRATE 0x00000020 // all tx rate statistics (within interface statistics)
#define WIFI_STATS_IFACE_AC 0x00000040 // all ac statistics (within interface statistics)
#define WIFI_STATS_IFACE_CONTENTION \
0x00000080 // all contention (min, max, avg) statistics (within ac statisctics)
/* clear api to reset statistics, stats_clear_rsp_mask identifies what stats have been cleared
stop_req = 1 will imply whether to stop the statistics collection.
stop_rsp = 1 will imply that stop_req was honored and statistics collection was stopped.
*/
wifi_error wifi_clear_link_stats(wifi_interface_handle iface, u32 stats_clear_req_mask,
u32* stats_clear_rsp_mask, u8 stop_req, u8* stop_rsp);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /*__WIFI_HAL_STATS_ */

40
wifi/1.6/default/hal_legacy/power.h
View File

@@ -1,40 +0,0 @@
/*
* Copyright (C) 2008 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 _HARDWARE_POWER_H
#define _HARDWARE_POWER_H
#include <stdint.h>
#if __cplusplus
extern "C" {
#endif
enum {
PARTIAL_WAKE_LOCK = 1, // the cpu stays on, but the screen is off
FULL_WAKE_LOCK = 2 // the screen is also on
};
// while you have a lock held, the device will stay on at least at the
// level you request.
int acquire_wake_lock(int lock, const char* id);
int release_wake_lock(const char* id);
#if __cplusplus
} // extern "C"
#endif
#endif // _HARDWARE_POWER_H

57
wifi/1.6/default/hal_legacy/roam.h
View File

@@ -1,57 +0,0 @@
/*
* 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_HAL_ROAM_H__
#define __WIFI_HAL_ROAM_H__
#include "wifi_hal.h"
#define MAX_BLACKLIST_BSSID 16
#define MAX_WHITELIST_SSID 8
#define MAX_SSID_LENGTH 32
typedef struct {
u32 max_blacklist_size;
u32 max_whitelist_size;
} wifi_roaming_capabilities;
typedef enum { ROAMING_DISABLE, ROAMING_ENABLE } fw_roaming_state_t;
typedef struct {
u32 length;
char ssid_str[MAX_SSID_LENGTH];
} ssid_t;
typedef struct {
u32 num_blacklist_bssid; // Number of bssids valid in blacklist_bssid[].
mac_addr blacklist_bssid[MAX_BLACKLIST_BSSID]; // List of bssids which should not be considered
// for romaing by firmware/driver.
u32 num_whitelist_ssid; // Number of ssids valid in whitelist_ssid[].
ssid_t whitelist_ssid[MAX_WHITELIST_SSID]; // List of ssids to which firmware/driver can
// consider to roam to.
} wifi_roaming_config;
/* Get the chipset roaming capabilities. */
wifi_error wifi_get_roaming_capabilities(wifi_interface_handle handle,
wifi_roaming_capabilities* caps);
/* Enable/disable firmware roaming */
wifi_error wifi_enable_firmware_roaming(wifi_interface_handle handle, fw_roaming_state_t state);
/* Pass down the blacklist BSSID and whitelist SSID to firmware. */
wifi_error wifi_configure_roaming(wifi_interface_handle handle,
wifi_roaming_config* roaming_config);
#endif /* __WIFI_HAL_ROAM_H__ */

314
wifi/1.6/default/hal_legacy/rtt.h
View File

@@ -1,314 +0,0 @@
#include "gscan.h"
#include "wifi_hal.h"
#ifndef __WIFI_HAL_RTT_H__
#define __WIFI_HAL_RTT_H__
/* Ranging status */
typedef enum {
RTT_STATUS_SUCCESS = 0,
RTT_STATUS_FAILURE = 1, // general failure status
RTT_STATUS_FAIL_NO_RSP = 2, // target STA does not respond to request
RTT_STATUS_FAIL_REJECTED = 3, // request rejected. Applies to 2-sided RTT only
RTT_STATUS_FAIL_NOT_SCHEDULED_YET = 4,
RTT_STATUS_FAIL_TM_TIMEOUT = 5, // timing measurement times out
RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL = 6, // Target on different channel, cannot range
RTT_STATUS_FAIL_NO_CAPABILITY = 7, // ranging not supported
RTT_STATUS_ABORTED = 8, // request aborted for unknown reason
RTT_STATUS_FAIL_INVALID_TS = 9, // Invalid T1-T4 timestamp
RTT_STATUS_FAIL_PROTOCOL = 10, // 11mc protocol failed
RTT_STATUS_FAIL_SCHEDULE = 11, // request could not be scheduled
RTT_STATUS_FAIL_BUSY_TRY_LATER = 12, // responder cannot collaborate at time of request
RTT_STATUS_INVALID_REQ = 13, // bad request args
RTT_STATUS_NO_WIFI = 14, // WiFi not enabled
RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE =
15, // Responder overrides param info, cannot range with new params
RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE = 16, // Negotiation failure
RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED = 17, // concurrency not supported (NDP+RTT)
} wifi_rtt_status;
/* RTT peer type */
typedef enum {
RTT_PEER_AP = 0x1,
RTT_PEER_STA = 0x2,
RTT_PEER_P2P_GO = 0x3,
RTT_PEER_P2P_CLIENT = 0x4,
RTT_PEER_NAN = 0x5
} rtt_peer_type;
/* RTT Measurement Bandwidth */
typedef enum {
WIFI_RTT_BW_5 = 0x01,
WIFI_RTT_BW_10 = 0x02,
WIFI_RTT_BW_20 = 0x04,
WIFI_RTT_BW_40 = 0x08,
WIFI_RTT_BW_80 = 0x10,
WIFI_RTT_BW_160 = 0x20,
WIFI_RTT_BW_320 = 0x40
} wifi_rtt_bw;
/* RTT Measurement Preamble */
typedef enum {
WIFI_RTT_PREAMBLE_LEGACY = 0x1,
WIFI_RTT_PREAMBLE_HT = 0x2,
WIFI_RTT_PREAMBLE_VHT = 0x4,
WIFI_RTT_PREAMBLE_HE = 0x8,
WIFI_RTT_PREAMBLE_EHT = 0x10,
} wifi_rtt_preamble;
/* RTT Type */
typedef enum {
RTT_TYPE_1_SIDED = 0x1,
RTT_TYPE_2_SIDED = 0x2,
} wifi_rtt_type;
/* RTT configuration */
typedef struct {
mac_addr addr; // peer device mac address
wifi_rtt_type type; // 1-sided or 2-sided RTT
rtt_peer_type peer; // optional - peer device hint (STA, P2P, AP)
wifi_channel_info channel; // Required for STA-AP mode, optional for P2P, NBD etc.
unsigned burst_period; // Time interval between bursts (units: 100 ms).
// Applies to 1-sided and 2-sided RTT multi-burst requests.
// Range: 0-31, 0: no preference by initiator (2-sided RTT)
unsigned num_burst; // Total number of RTT bursts to be executed. It will be
// specified in the same way as the parameter "Number of
// Burst Exponent" found in the FTM frame format. It
// applies to both: 1-sided RTT and 2-sided RTT. Valid
// values are 0 to 15 as defined in 802.11mc std.
// 0 means single shot
// The implication of this parameter on the maximum
// number of RTT results is the following:
// for 1-sided RTT: max num of RTT results =
// (2^num_burst)*(num_frames_per_burst) for 2-sided RTT: max num of RTT
// results = (2^num_burst)*(num_frames_per_burst - 1)
unsigned num_frames_per_burst; // num of frames per burst.
// Minimum value = 1, Maximum value = 31
// For 2-sided this equals the number of FTM frames
// to be attempted in a single burst. This also
// equals the number of FTM frames that the
// initiator will request that the responder send
// in a single frame.
unsigned
num_retries_per_rtt_frame; // number of retries for a failed RTT frame. Applies
// to 1-sided RTT only. Minimum value = 0, Maximum value = 3
// following fields are only valid for 2-side RTT
unsigned num_retries_per_ftmr; // Maximum number of retries that the initiator can
// retry an FTMR frame.
// Minimum value = 0, Maximum value = 3
byte LCI_request; // 1: request LCI, 0: do not request LCI
byte LCR_request; // 1: request LCR, 0: do not request LCR
unsigned burst_duration; // Applies to 1-sided and 2-sided RTT. Valid values will
// be 2-11 and 15 as specified by the 802.11mc std for
// the FTM parameter burst duration. In a multi-burst
// request, if responder overrides with larger value,
// the initiator will return failure. In a single-burst
// request if responder overrides with larger value,
// the initiator will sent TMR_STOP to terminate RTT
// at the end of the burst_duration it requested.
wifi_rtt_preamble preamble; // RTT preamble to be used in the RTT frames
wifi_rtt_bw bw; // RTT BW to be used in the RTT frames
} wifi_rtt_config;
/* RTT results */
typedef struct {
mac_addr addr; // device mac address
unsigned burst_num; // burst number in a multi-burst request
unsigned measurement_number; // Total RTT measurement frames attempted
unsigned success_number; // Total successful RTT measurement frames
byte number_per_burst_peer; // Maximum number of "FTM frames per burst" supported by
// the responder STA. Applies to 2-sided RTT only.
// If reponder overrides with larger value:
// - for single-burst request initiator will truncate the
// larger value and send a TMR_STOP after receiving as
// many frames as originally requested.
// - for multi-burst request, initiator will return
// failure right away.
wifi_rtt_status status; // ranging status
byte retry_after_duration; // When status == RTT_STATUS_FAIL_BUSY_TRY_LATER,
// this will be the time provided by the responder as to
// when the request can be tried again. Applies to 2-sided
// RTT only. In sec, 1-31sec.
wifi_rtt_type type; // RTT type
wifi_rssi rssi; // average rssi in 0.5 dB steps e.g. 143 implies -71.5 dB
wifi_rssi rssi_spread; // rssi spread in 0.5 dB steps e.g. 5 implies 2.5 dB spread (optional)
wifi_rate tx_rate; // 1-sided RTT: TX rate of RTT frame.
// 2-sided RTT: TX rate of initiator's Ack in response to FTM frame.
wifi_rate rx_rate; // 1-sided RTT: TX rate of Ack from other side.
// 2-sided RTT: TX rate of FTM frame coming from responder.
wifi_timespan rtt; // round trip time in picoseconds
wifi_timespan rtt_sd; // rtt standard deviation in picoseconds
wifi_timespan rtt_spread; // difference between max and min rtt times recorded in picoseconds
int distance_mm; // distance in mm (optional)
int distance_sd_mm; // standard deviation in mm (optional)
int distance_spread_mm; // difference between max and min distance recorded in mm (optional)
wifi_timestamp ts; // time of the measurement (in microseconds since boot)
int burst_duration; // in ms, actual time taken by the FW to finish one burst
// measurement. Applies to 1-sided and 2-sided RTT.
int negotiated_burst_num; // Number of bursts allowed by the responder. Applies
// to 2-sided RTT only.
wifi_information_element* LCI; // for 11mc only
wifi_information_element* LCR; // for 11mc only
} wifi_rtt_result;
/* RTT result callback */
typedef struct {
void (*on_rtt_results)(wifi_request_id id, unsigned num_results, wifi_rtt_result* rtt_result[]);
} wifi_rtt_event_handler;
/* API to request RTT measurement */
wifi_error wifi_rtt_range_request(wifi_request_id id, wifi_interface_handle iface,
unsigned num_rtt_config, wifi_rtt_config rtt_config[],
wifi_rtt_event_handler handler);
/* API to cancel RTT measurements */
wifi_error wifi_rtt_range_cancel(wifi_request_id id, wifi_interface_handle iface,
unsigned num_devices, mac_addr addr[]);
/* NBD ranging channel map */
typedef struct {
wifi_channel availablity[32]; // specifies the channel map for each of the 16 TU windows
// frequency of 0 => unspecified; which means firmware is
// free to do whatever it wants in this window.
} wifi_channel_map;
/* API to start publishing the channel map on responder device in a NBD cluster.
Responder device will take this request and schedule broadcasting the channel map
in a NBD ranging attribute in a SDF. DE will automatically remove the ranging
attribute from the OTA queue after number of DW specified by num_dw
where Each DW is 512 TUs apart */
wifi_error wifi_rtt_channel_map_set(wifi_request_id id, wifi_interface_handle iface,
wifi_channel_map* params, unsigned num_dw);
/* API to clear the channel map on the responder device in a NBD cluster.
Responder device will cancel future ranging channel request, starting from “next”
DW interval and will also stop broadcasting NBD ranging attribute in SDF */
wifi_error wifi_rtt_channel_map_clear(wifi_request_id id, wifi_interface_handle iface);
// Preamble definition for bit mask used in wifi_rtt_capabilities
#define PREAMBLE_LEGACY 0x1
#define PREAMBLE_HT 0x2
#define PREAMBLE_VHT 0x4
#define PREAMBLE_HE 0x8
#define PREAMBLE_EHT 0x10
// BW definition for bit mask used in wifi_rtt_capabilities
#define BW_5_SUPPORT 0x1
#define BW_10_SUPPORT 0x2
#define BW_20_SUPPORT 0x4
#define BW_40_SUPPORT 0x8
#define BW_80_SUPPORT 0x10
#define BW_160_SUPPORT 0x20
#define BW_320_SUPPORT 0x40
/* RTT Capabilities */
typedef struct {
byte rtt_one_sided_supported; // if 1-sided rtt data collection is supported
byte rtt_ftm_supported; // if ftm rtt data collection is supported
byte lci_support; // if initiator supports LCI request. Applies to 2-sided RTT
byte lcr_support; // if initiator supports LCR request. Applies to 2-sided RTT
byte preamble_support; // bit mask indicates what preamble is supported by initiator
byte bw_support; // bit mask indicates what BW is supported by initiator
byte responder_supported; // if 11mc responder mode is supported
byte mc_version; // draft 11mc spec version supported by chip. For instance,
// version 4.0 should be 40 and version 4.3 should be 43 etc.
} wifi_rtt_capabilities;
/* RTT capabilities of the device */
wifi_error wifi_get_rtt_capabilities(wifi_interface_handle iface,
wifi_rtt_capabilities* capabilities);
/* debugging definitions */
enum {
RTT_DEBUG_DISABLE,
RTT_DEBUG_LOG,
RTT_DEBUG_PROTO,
RTT_DEBUG_BURST,
RTT_DEBUG_ACCURACY,
RTT_DEBUG_LOGDETAIL
}; // rtt debug type
enum { RTT_DEBUG_FORMAT_TXT, RTT_DEBUG_FORMAT_BINARY }; // rtt debug format
typedef struct rtt_debug {
unsigned version;
unsigned len; // total length of after len field
unsigned type; // rtt debug type
unsigned format; // rtt debug format
char dbuf[0]; // debug content
} rtt_debug_t;
/* set configuration for debug */
wifi_error wifi_rtt_debug_cfg(wifi_interface_handle h, unsigned rtt_dbg_type, char* cfgbuf,
unsigned cfg_buf_size);
/* get the debug information */
wifi_error wifi_rtt_debug_get(wifi_interface_handle h, rtt_debug_t** debugbuf);
/* free the debug buffer */
wifi_error wifi_rtt_debug_free(wifi_interface_handle h, rtt_debug_t* debugbuf);
/* API for setting LCI/LCR information to be provided to a requestor */
typedef enum {
WIFI_MOTION_NOT_EXPECTED = 0, // Not expected to change location
WIFI_MOTION_EXPECTED = 1, // Expected to change location
WIFI_MOTION_UNKNOWN = 2, // Movement pattern unknown
} wifi_motion_pattern;
typedef struct {
long latitude; // latitude in degrees * 2^25 , 2's complement
long longitude; // latitude in degrees * 2^25 , 2's complement
int altitude; // Altitude in units of 1/256 m
byte latitude_unc; // As defined in Section 2.3.2 of IETF RFC 6225
byte longitude_unc; // As defined in Section 2.3.2 of IETF RFC 6225
byte altitude_unc; // As defined in Section 2.4.5 from IETF RFC 6225:
// Following element for configuring the Z subelement
wifi_motion_pattern motion_pattern;
int floor; // floor in units of 1/16th of floor. 0x80000000 if unknown.
int height_above_floor; // in units of 1/64 m
int height_unc; // in units of 1/64 m. 0 if unknown
} wifi_lci_information;
typedef struct {
char country_code[2]; // country code
int length; // length of the info field
char civic_info[256]; // Civic info to be copied in FTM frame
} wifi_lcr_information;
// API to configure the LCI. Used in RTT Responder mode only
wifi_error wifi_set_lci(wifi_request_id id, wifi_interface_handle iface, wifi_lci_information* lci);
// API to configure the LCR. Used in RTT Responder mode only.
wifi_error wifi_set_lcr(wifi_request_id id, wifi_interface_handle iface, wifi_lcr_information* lcr);
/**
* RTT Responder information
*/
typedef struct {
wifi_channel_info channel;
wifi_rtt_preamble preamble;
} wifi_rtt_responder;
/**
* Get RTT responder information e.g. WiFi channel to enable responder on.
*/
wifi_error wifi_rtt_get_responder_info(wifi_interface_handle iface,
wifi_rtt_responder* responder_info);
/**
* Enable RTT responder mode.
* channel_hint - hint of the channel information where RTT responder should be enabled on.
* max_duration_seconds - timeout of responder mode.
* channel_used - channel used for RTT responder, NULL if responder is not enabled.
*/
wifi_error wifi_enable_responder(wifi_request_id id, wifi_interface_handle iface,
wifi_channel_info channel_hint, unsigned max_duration_seconds,
wifi_rtt_responder* responder_info);
/**
* Disable RTT responder mode.
*/
wifi_error wifi_disable_responder(wifi_request_id id, wifi_interface_handle iface);
#endif

84
wifi/1.6/default/hal_legacy/tdls.h
View File

@@ -1,84 +0,0 @@
#include "wifi_hal.h"
#ifndef _TDLS_H_
#define _TDLS_H_
typedef enum {
WIFI_TDLS_DISABLED = 1, /* TDLS is not enabled, default status for all STAs */
WIFI_TDLS_ENABLED, /* TDLS is enabled, but not yet tried */
WIFI_TDLS_ESTABLISHED, /* Direct link is established */
WIFI_TDLS_ESTABLISHED_OFF_CHANNEL, /* Direct link is established using MCC */
WIFI_TDLS_DROPPED, /* Direct link was established,
* but is temporarily dropped now */
WIFI_TDLS_FAILED /* TDLS permanent failed. Inform error to upper layer
* and go back to WIFI_TDLS_DISABLED */
} wifi_tdls_state;
typedef enum {
WIFI_TDLS_SUCCESS, /* Success */
WIFI_TDLS_UNSPECIFIED = -1, /* Unspecified reason */
WIFI_TDLS_NOT_SUPPORTED = -2, /* Remote side doesn't support TDLS */
WIFI_TDLS_UNSUPPORTED_BAND = -3, /* Remote side doesn't support this band */
WIFI_TDLS_NOT_BENEFICIAL = -4, /* Going to AP is better than going direct */
WIFI_TDLS_DROPPED_BY_REMOTE = -5 /* Remote side doesn't want it anymore */
} wifi_tdls_reason;
typedef struct {
int channel; /* channel hint, in channel number (NOT frequency ) */
int global_operating_class; /* operating class to use */
int max_latency_ms; /* max latency that can be tolerated by apps */
int min_bandwidth_kbps; /* bandwidth required by apps, in kilo bits per second */
} wifi_tdls_params;
typedef struct {
int channel;
int global_operating_class;
wifi_tdls_state state;
wifi_tdls_reason reason;
} wifi_tdls_status;
typedef struct {
int max_concurrent_tdls_session_num; /* Maximum TDLS session number can be supported by the
* Firmware and hardware*/
int is_global_tdls_supported; /* 1 -- support, 0 -- not support */
int is_per_mac_tdls_supported; /* 1 -- support, 0 -- not support */
int is_off_channel_tdls_supported; /* 1 -- support, 0 -- not support */
} wifi_tdls_capabilities;
typedef struct {
/* on_tdls_state_changed - reports state of TDLS link to framework
* Report this event when the state of TDLS link changes */
void (*on_tdls_state_changed)(mac_addr addr, wifi_tdls_status status);
} wifi_tdls_handler;
/* wifi_enable_tdls - enables TDLS-auto mode for a specific route
*
* params specifies hints, which provide more information about
* why TDLS is being sought. The firmware should do its best to
* honor the hints before downgrading regular AP link
* If upper layer has no specific values, this should be NULL
*
* handler is used to inform the upper layer about the status change and the corresponding reason
*/
wifi_error wifi_enable_tdls(wifi_interface_handle iface, mac_addr addr, wifi_tdls_params* params,
wifi_tdls_handler handler);
/* wifi_disable_tdls - disables TDLS-auto mode for a specific route
*
* This terminates any existing TDLS with addr device, and frees the
* device resources to make TDLS connections on new routes.
*
* DON'T fire any more events on 'handler' specified in earlier call to
* wifi_enable_tdls after this action.
*/
wifi_error wifi_disable_tdls(wifi_interface_handle iface, mac_addr addr);
/* wifi_get_tdls_status - allows getting the status of TDLS for a specific route */
wifi_error wifi_get_tdls_status(wifi_interface_handle iface, mac_addr addr,
wifi_tdls_status* status);
/* return the current HW + Firmware combination's TDLS capabilities */
wifi_error wifi_get_tdls_capabilities(wifi_interface_handle iface,
wifi_tdls_capabilities* capabilities);
#endif

35
wifi/1.6/default/hal_legacy/uevent.h
View File

@@ -1,35 +0,0 @@
/*
* Copyright (C) 2008 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 _HARDWARE_UEVENT_H
#define _HARDWARE_UEVENT_H
#if __cplusplus
extern "C" {
#endif
int uevent_init();
int uevent_get_fd();
int uevent_next_event(char* buffer, int buffer_length);
int uevent_add_native_handler(void (*handler)(void* data, const char* msg, int msg_len),
void* handler_data);
int uevent_remove_native_handler(void (*handler)(void* data, const char* msg, int msg_len));
#if __cplusplus
} // extern "C"
#endif
#endif // _HARDWARE_UEVENT_H

92
wifi/1.6/default/hal_legacy/wifi_cached_scan_results.h
View File

@@ -1,92 +0,0 @@
/*
* Copyright (C) 2022 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_CACHED_SCAN_RESULTS_H__
#define __WIFI_CACHED_SCAN_RESULTS_H__
#include "wifi_hal.h"
#define WIFI_CACHED_SCAN_RESULT_FLAGS_NONE (0)
/* Element ID 61 (HT Operation) is present (see HT 7.3.2) */
#define WIFI_CACHED_SCAN_RESULT_FLAGS_HT_OPS_PRESENT (1 << 0)
/* Element ID 192 (VHT Operation) is present (see VHT 8.4.2) */
#define WIFI_CACHED_SCAN_RESULT_FLAGS_VHT_OPS_PRESENT (1 << 1)
/* Element ID 255 + Extension 36 (HE Operation) is present
* (see 802.11ax 9.4.2.1)
*/
#define WIFI_CACHED_SCAN_RESULT_FLAGS_HE_OPS_PRESENT (1 << 2)
/* Element ID 255 + Extension 106 (HE Operation) is present
* (see 802.11be D1.5 9.4.2.1)
*/
#define WIFI_CACHED_SCAN_RESULT_FLAGS_EHT_OPS_PRESENT (1 << 3)
/* Element ID 127 (Extended Capabilities) is present, and bit 70
* (Fine Timing Measurement Responder) is set to 1
* (see IEEE Std 802.11-2016 9.4.2.27)
*/
#define WIFI_CACHED_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER (1 << 4)
/**
* Provides information about a single access point (AP) detected in a scan.
*/
typedef struct {
/* Number of milliseconds prior to ts in the enclosing
* wifi_cached_scan_result_report struct when
* the probe response or beacon frame that
* was used to populate this structure was received.
*/
u32 age_ms;
/* The Capability Information field */
u16 capability;
/* null terminated */
u8 ssid[33];
u8 ssid_len;
u8 bssid[6];
/* A set of flags from WIFI_CACHED_SCAN_RESULT_FLAGS_* */
u8 flags;
s8 rssi;
wifi_channel_spec chanspec;
} wifi_cached_scan_result;
/*
* Data structure sent with events of type WifiCachedScanResult.
*/
typedef struct {
/* time since boot (in microsecond) when the result was retrieved */
wifi_timestamp ts;
/* If 0, indicates that all frequencies in current regulation were
* scanned. Otherwise, indicates the number of frequencies scanned, as
* specified in scanned_freq_list.
*/
u16 scanned_freq_num;
/* Pointer to an array containing scanned_freq_num values comprising the
* set of frequencies that were scanned. Frequencies are specified as
* channel center frequencies in MHz. May be NULL if scannedFreqListLen is
* 0.
*/
const u32* scanned_freq_list;
/* The total number of cached results returned. */
u8 result_cnt;
/* Pointer to an array containing result_cnt entries. May be NULL if
* result_cnt is 0.
*/
const wifi_cached_scan_result* results;
} wifi_cached_scan_report;
/* callback for reporting cached scan report */
typedef struct {
void (*on_cached_scan_results)(wifi_cached_scan_report* cache_report);
} wifi_cached_scan_result_handler;
#endif

44
wifi/1.6/default/hal_legacy/wifi_config.h
View File

@@ -1,44 +0,0 @@
#include "wifi_hal.h"
#ifndef __WIFI_HAL_CONFIG_H
#define __WIFI_HAL_CONFIG_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define CONFIG_MAJOR_VERSION 1
#define CONFIG_MINOR_VERSION 0
#define CONFIG_MICRO_VERSION 0
// whether the wifi chipset wakes at every dtim beacon or a multiple of the dtim period
// if extended_dtim is set to 3, the STA shall wake up every 3 DTIM beacons
wifi_error wifi_extended_dtim_config_set(wifi_request_id id, wifi_interface_handle iface,
int extended_dtim);
// set the country code to driver
wifi_error wifi_set_country_code(wifi_interface_handle iface, const char* country_code);
// set the wifi_iface stats averaging factor used to calculate
// statistics like average the TSF offset or average number of frame leaked
// For instance, upon beacon reception:
// current_avg = ((beacon_TSF - TBTT) * factor + previous_avg * (0x10000 - factor) ) / 0x10000
// For instance, when evaluating leaky APs:
// current_avg = ((num frame received within guard time) * factor + previous_avg * (0x10000 -
// factor)) / 0x10000
wifi_error wifi_set_beacon_wifi_iface_stats_averaging_factor(wifi_request_id id,
wifi_interface_handle iface,
u16 factor);
// configure guard time, i.e. when implementing IEEE power management based on
// frame control PM bit, how long driver waits before shutting down the radio and
// after receiving an ACK for a data frame with PM bit set
wifi_error wifi_set_guard_time(wifi_request_id id, wifi_interface_handle iface, u32 guard_time);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /*__WIFI_HAL_STATS_ */

1020
wifi/1.6/default/hal_legacy/wifi_hal.h
View File

File diff suppressed because it is too large Load Diff

650
wifi/1.6/default/hal_legacy/wifi_logger.h
View File

@@ -1,650 +0,0 @@
#include "wifi_hal.h"
#ifndef __WIFI_HAL_LOGGER_H
#define __WIFI_HAL_LOGGER_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define LOGGER_MAJOR_VERSION 1
#define LOGGER_MINOR_VERSION 0
#define LOGGER_MICRO_VERSION 0
/**
* WiFi logger life cycle is as follow:
*
* - At initialization time, framework will call wifi_get_ring_buffers_status
* so as to obtain the names and list of supported buffers.
* - When WiFi operation start framework will call wifi_start_logging
* so as to trigger log collection.
* - Developper UI will provide an option to the user, so as it can set the verbose level
* of individual buffer as reported by wifi_get_ring_buffers_status.
* - During wifi operations, driver will periodically report per ring data to framework
* by invoking the on_ring_buffer_data call back.
* - when capturing a bug report, framework will indicate to driver that all the data
* has to be uploaded, urgently, by calling wifi_get_ring_data.
*
* The data uploaded by driver will be stored by framework in separate files, with one stream
* of file per ring.
* Framework will store the files in pcapng format, allowing for easy merging and parsing
* with network analyzer tools.
*/
typedef int wifi_ring_buffer_id;
#define PER_PACKET_ENTRY_FLAGS_DIRECTION_TX 1 // 0: TX, 1: RX
#define PER_PACKET_ENTRY_FLAGS_TX_SUCCESS \
2 // whether packet was transmitted or
// received/decrypted successfully
#define PER_PACKET_ENTRY_FLAGS_80211_HEADER 4 // has full 802.11 header, else has 802.3 header
#define PER_PACKET_ENTRY_FLAGS_PROTECTED 8 // whether packet was encrypted
typedef struct {
u8 flags;
u8 tid; // transmit or received tid
u16 MCS; // modulation and bandwidth
u8 rssi; // TX: RSSI of ACK for that packet
// RX: RSSI of packet
u8 num_retries; // number of attempted retries
u16 last_transmit_rate; // last transmit rate in .5 mbps
u16 link_layer_transmit_sequence; // transmit/reeive sequence for that MPDU packet
u64 firmware_entry_timestamp; // TX: firmware timestamp (us) when packet is queued within
// firmware buffer for SDIO/HSIC or into PCIe buffer
// RX: firmware receive timestamp
u64 start_contention_timestamp; // firmware timestamp (us) when packet start contending for the
// medium for the first time, at head of its AC queue,
// or as part of an MPDU or A-MPDU. This timestamp is
// not updated for each retry, only the first transmit attempt.
u64 transmit_success_timestamp; // fimrware timestamp (us) when packet is successfully
// transmitted or aborted because it has exhausted
// its maximum number of retries.
u8 data[0]; // packet data. The length of packet data is determined by the entry_size field of
// the wifi_ring_buffer_entry structure. It is expected that first bytes of the
// packet, or packet headers only (up to TCP or RTP/UDP headers)
// will be copied into the ring
} __attribute__((packed)) wifi_ring_per_packet_status_entry;
/* Below events refer to the wifi_connectivity_event ring and shall be supported */
#define WIFI_EVENT_ASSOCIATION_REQUESTED 0 // driver receives association command from kernel
#define WIFI_EVENT_AUTH_COMPLETE 1
#define WIFI_EVENT_ASSOC_COMPLETE 2
#define WIFI_EVENT_FW_AUTH_STARTED 3 // fw event indicating auth frames are sent
#define WIFI_EVENT_FW_ASSOC_STARTED 4 // fw event indicating assoc frames are sent
#define WIFI_EVENT_FW_RE_ASSOC_STARTED 5 // fw event indicating reassoc frames are sent
#define WIFI_EVENT_DRIVER_SCAN_REQUESTED 6
#define WIFI_EVENT_DRIVER_SCAN_RESULT_FOUND 7
#define WIFI_EVENT_DRIVER_SCAN_COMPLETE 8
#define WIFI_EVENT_G_SCAN_STARTED 9
#define WIFI_EVENT_G_SCAN_COMPLETE 10
#define WIFI_EVENT_DISASSOCIATION_REQUESTED 11
#define WIFI_EVENT_RE_ASSOCIATION_REQUESTED 12
#define WIFI_EVENT_ROAM_REQUESTED 13
#define WIFI_EVENT_BEACON_RECEIVED \
14 // received beacon from AP (event enabled
// only in verbose mode)
#define WIFI_EVENT_ROAM_SCAN_STARTED 15 // firmware has triggered a roam scan (not g-scan)
#define WIFI_EVENT_ROAM_SCAN_COMPLETE 16 // firmware has completed a roam scan (not g-scan)
#define WIFI_EVENT_ROAM_SEARCH_STARTED \
17 // firmware has started searching for roam
// candidates (with reason =xx)
#define WIFI_EVENT_ROAM_SEARCH_STOPPED \
18 // firmware has stopped searching for roam
// candidates (with reason =xx)
#define WIFI_EVENT_CHANNEL_SWITCH_ANOUNCEMENT 20 // received channel switch anouncement from AP
#define WIFI_EVENT_FW_EAPOL_FRAME_TRANSMIT_START \
21 // fw start transmit eapol frame, with
// EAPOL index 1-4
#define WIFI_EVENT_FW_EAPOL_FRAME_TRANSMIT_STOP \
22 // fw gives up eapol frame, with rate,
// success/failure and number retries
#define WIFI_EVENT_DRIVER_EAPOL_FRAME_TRANSMIT_REQUESTED \
23 // kernel queue EAPOL for transmission
// in driver with EAPOL index 1-4
#define WIFI_EVENT_FW_EAPOL_FRAME_RECEIVED \
24 // with rate, regardless of the fact that
// EAPOL frame is accepted or rejected by fw
#define WIFI_EVENT_DRIVER_EAPOL_FRAME_RECEIVED \
26 // with rate, and eapol index, driver has
// received EAPOL frame and will queue it up
// to wpa_supplicant
#define WIFI_EVENT_BLOCK_ACK_NEGOTIATION_COMPLETE 27 // with success/failure, parameters
#define WIFI_EVENT_BT_COEX_BT_SCO_START 28
#define WIFI_EVENT_BT_COEX_BT_SCO_STOP 29
#define WIFI_EVENT_BT_COEX_BT_SCAN_START \
30 // for paging/scan etc., when BT starts transmiting
// twice per BT slot
#define WIFI_EVENT_BT_COEX_BT_SCAN_STOP 31
#define WIFI_EVENT_BT_COEX_BT_HID_START 32
#define WIFI_EVENT_BT_COEX_BT_HID_STOP 33
#define WIFI_EVENT_ROAM_AUTH_STARTED 34 // fw sends auth frame in roaming to next candidate
#define WIFI_EVENT_ROAM_AUTH_COMPLETE 35 // fw receive auth confirm from ap
#define WIFI_EVENT_ROAM_ASSOC_STARTED \
36 // firmware sends assoc/reassoc frame in
// roaming to next candidate
#define WIFI_EVENT_ROAM_ASSOC_COMPLETE 37 // firmware receive assoc/reassoc confirm from ap
#define WIFI_EVENT_G_SCAN_STOP 38 // firmware sends stop G_SCAN
#define WIFI_EVENT_G_SCAN_CYCLE_STARTED 39 // firmware indicates G_SCAN scan cycle started
#define WIFI_EVENT_G_SCAN_CYCLE_COMPLETED 40 // firmware indicates G_SCAN scan cycle completed
#define WIFI_EVENT_G_SCAN_BUCKET_STARTED \
41 // firmware indicates G_SCAN scan start
// for a particular bucket
#define WIFI_EVENT_G_SCAN_BUCKET_COMPLETED \
42 // firmware indicates G_SCAN scan completed for
// for a particular bucket
#define WIFI_EVENT_G_SCAN_RESULTS_AVAILABLE \
43 // Event received from firmware about G_SCAN scan
// results being available
#define WIFI_EVENT_G_SCAN_CAPABILITIES \
44 // Event received from firmware with G_SCAN
// capabilities
#define WIFI_EVENT_ROAM_CANDIDATE_FOUND \
45 // Event received from firmware when eligible
// candidate is found
#define WIFI_EVENT_ROAM_SCAN_CONFIG \
46 // Event received from firmware when roam scan
// configuration gets enabled or disabled
#define WIFI_EVENT_AUTH_TIMEOUT 47 // firmware/driver timed out authentication
#define WIFI_EVENT_ASSOC_TIMEOUT 48 // firmware/driver timed out association
#define WIFI_EVENT_MEM_ALLOC_FAILURE 49 // firmware/driver encountered allocation failure
#define WIFI_EVENT_DRIVER_PNO_ADD 50 // driver added a PNO network in firmware
#define WIFI_EVENT_DRIVER_PNO_REMOVE 51 // driver removed a PNO network in firmware
#define WIFI_EVENT_DRIVER_PNO_NETWORK_FOUND \
52 // driver received PNO networks
// found indication from firmware
#define WIFI_EVENT_DRIVER_PNO_SCAN_REQUESTED 53 // driver triggered a scan for PNO networks
#define WIFI_EVENT_DRIVER_PNO_SCAN_RESULT_FOUND \
54 // driver received scan results
// of PNO networks
#define WIFI_EVENT_DRIVER_PNO_SCAN_COMPLETE \
55 // driver updated scan results from
// PNO networks to cfg80211
/**
* Parameters of wifi logger events are TLVs
* Event parameters tags are defined as:
*/
#define WIFI_TAG_VENDOR_SPECIFIC 0 // take a byte stream as parameter
#define WIFI_TAG_BSSID 1 // takes a 6 bytes MAC address as parameter
#define WIFI_TAG_ADDR 2 // takes a 6 bytes MAC address as parameter
#define WIFI_TAG_SSID 3 // takes a 32 bytes SSID address as parameter
#define WIFI_TAG_STATUS 4 // takes an integer as parameter
#define WIFI_TAG_CHANNEL_SPEC 5 // takes one or more wifi_channel_spec as parameter
#define WIFI_TAG_WAKE_LOCK_EVENT 6 // takes a wake_lock_event struct as parameter
#define WIFI_TAG_ADDR1 7 // takes a 6 bytes MAC address as parameter
#define WIFI_TAG_ADDR2 8 // takes a 6 bytes MAC address as parameter
#define WIFI_TAG_ADDR3 9 // takes a 6 bytes MAC address as parameter
#define WIFI_TAG_ADDR4 10 // takes a 6 bytes MAC address as parameter
#define WIFI_TAG_TSF 11 // take a 64 bits TSF value as parameter
#define WIFI_TAG_IE \
12 // take one or more specific 802.11 IEs parameter,
// IEs are in turn indicated in TLV format as per
// 802.11 spec
#define WIFI_TAG_INTERFACE 13 // take interface name as parameter
#define WIFI_TAG_REASON_CODE 14 // take a reason code as per 802.11 as parameter
#define WIFI_TAG_RATE_MBPS 15 // take a wifi rate in 0.5 mbps
#define WIFI_TAG_REQUEST_ID 16 // take an integer as parameter
#define WIFI_TAG_BUCKET_ID 17 // take an integer as parameter
#define WIFI_TAG_GSCAN_PARAMS 18 // takes a wifi_scan_cmd_params struct as parameter
#define WIFI_TAG_GSCAN_CAPABILITIES 19 // takes a wifi_gscan_capabilities struct as parameter
#define WIFI_TAG_SCAN_ID 20 // take an integer as parameter
#define WIFI_TAG_RSSI 21 // take an integer as parameter
#define WIFI_TAG_CHANNEL 22 // take an integer as parameter
#define WIFI_TAG_LINK_ID 23 // take an integer as parameter
#define WIFI_TAG_LINK_ROLE 24 // take an integer as parameter
#define WIFI_TAG_LINK_STATE 25 // take an integer as parameter
#define WIFI_TAG_LINK_TYPE 26 // take an integer as parameter
#define WIFI_TAG_TSCO 27 // take an integer as parameter
#define WIFI_TAG_RSCO 28 // take an integer as parameter
#define WIFI_TAG_EAPOL_MESSAGE_TYPE \
29 // take an integer as parameter
// M1-1, M2-2, M3-3, M4-4
typedef struct {
u16 tag;
u16 length; // length of value
u8 value[0];
} __attribute__((packed)) tlv_log;
typedef struct {
u16 event;
tlv_log tlvs[0]; // separate parameter structure per event to be provided and optional data
// the event_data is expected to include an official android part, with some
// parameter as transmit rate, num retries, num scan result found etc...
// as well, event_data can include a vendor proprietary part which is
// understood by the developer only.
} __attribute__((packed)) wifi_ring_buffer_driver_connectivity_event;
/**
* Ring buffer name for power events ring. note that power event are extremely frequents
* and thus should be stored in their own ring/file so as not to clobber connectivity events.
*/
typedef struct {
int status; // 0 taken, 1 released
int reason; // reason why this wake lock is taken
char name[0]; // null terminated
} __attribute__((packed)) wake_lock_event;
typedef struct {
u16 event;
tlv_log tlvs[0];
} __attribute__((packed)) wifi_power_event;
/**
* This structure represent a logger entry within a ring buffer.
* Wifi driver are responsible to manage the ring buffer and write the debug
* information into those rings.
*
* In general, the debug entries can be used to store meaningful 802.11 information (SME, MLME,
* connection and packet statistics) as well as vendor proprietary data that is specific to a
* specific driver or chipset.
* Binary entries can be used so as to store packet data or vendor specific information and
* will be treated as blobs of data by android.
*
* A user land process will be started by framework so as to periodically retrieve the
* data logged by drivers into their ring buffer, store the data into log files and include
* the logs into android bugreports.
*/
enum {
RING_BUFFER_ENTRY_FLAGS_HAS_BINARY = (1 << (0)), // set for binary entries
RING_BUFFER_ENTRY_FLAGS_HAS_TIMESTAMP = (1 << (1)) // set if 64 bits timestamp is present
};
enum {
ENTRY_TYPE_CONNECT_EVENT = 1,
ENTRY_TYPE_PKT,
ENTRY_TYPE_WAKE_LOCK,
ENTRY_TYPE_POWER_EVENT,
ENTRY_TYPE_DATA
};
typedef struct {
u16 entry_size; // the size of payload excluding the header.
u8 flags;
u8 type; // entry type
u64 timestamp; // present if has_timestamp bit is set.
} __attribute__((packed)) wifi_ring_buffer_entry;
#define WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES 0x00000001 // set if binary entries are present
#define WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES 0x00000002 // set if ascii entries are present
/* ring buffer params */
/**
* written_bytes and read_bytes implement a producer consumer API
* hence written_bytes >= read_bytes
* a modulo arithmetic of the buffer size has to be applied to those counters:
* actual offset into ring buffer = written_bytes % ring_buffer_byte_size
*
*/
typedef struct {
u8 name[32];
u32 flags;
wifi_ring_buffer_id ring_id; // unique integer representing the ring
u32 ring_buffer_byte_size; // total memory size allocated for the buffer
u32 verbose_level; // verbose level for ring buffer
u32 written_bytes; // number of bytes that was written to the buffer by driver,
// monotonously increasing integer
u32 read_bytes; // number of bytes that was read from the buffer by user land,
// monotonously increasing integer
u32 written_records; // number of records that was written to the buffer by driver,
// monotonously increasing integer
} wifi_ring_buffer_status;
/**
* Callback for reporting ring data
*
* The ring buffer data collection is event based:
* - Driver calls on_ring_buffer_data when new records are available, the wifi_ring_buffer_status
* passed up to framework in the call back indicates to framework if more data is available in
* the ring buffer. It is not expected that driver will necessarily always empty the ring
* immediately as data is available, instead driver will report data every X seconds or if
* N bytes are available.
* - In the case where a bug report has to be captured, framework will require driver to upload
* all data immediately. This is indicated to driver when framework calls wifi_get_ringdata.
* When framework calls wifi_get_ring_data, driver will start sending all available data in the
* indicated ring by repeatedly invoking the on_ring_buffer_data callback.
*
* The callback is called by log handler whenever ring data comes in driver.
*/
typedef struct {
void (*on_ring_buffer_data)(char* ring_name, char* buffer, int buffer_size,
wifi_ring_buffer_status* status);
} wifi_ring_buffer_data_handler;
/**
* API to set the log handler for getting ring data
* - Only a single instance of log handler can be instantiated for each ring buffer.
*/
wifi_error wifi_set_log_handler(wifi_request_id id, wifi_interface_handle iface,
wifi_ring_buffer_data_handler handler);
/* API to reset the log handler */
wifi_error wifi_reset_log_handler(wifi_request_id id, wifi_interface_handle iface);
/**
* Callback for reporting FW dump
*
* The buffer data collection is event based such as FW health check or FW dump.
* The callback is called by alert handler.
*/
typedef struct {
void (*on_alert)(wifi_request_id id, char* buffer, int buffer_size, int err_code);
} wifi_alert_handler;
/*
* API to set the alert handler for the alert case in Wi-Fi Chip
* - Only a single instance of alert handler can be instantiated.
*/
wifi_error wifi_set_alert_handler(wifi_request_id id, wifi_interface_handle iface,
wifi_alert_handler handler);
/* API to reset the alert handler */
wifi_error wifi_reset_alert_handler(wifi_request_id id, wifi_interface_handle iface);
/* API for framework to indicate driver has to upload and drain all data of a given ring */
wifi_error wifi_get_ring_data(wifi_interface_handle iface, char* ring_name);
/**
* API to trigger the debug collection.
* Unless his API is invoked - logging is not triggered.
* - Verbose_level 0 corresponds to no collection,
* and it makes log handler stop by no more events from driver.
* - Verbose_level 1 correspond to normal log level, with minimal user impact.
* This is the default value.
* - Verbose_level 2 are enabled when user is lazily trying to reproduce a problem,
* wifi performances and power can be impacted but device should not otherwise be
* significantly impacted.
* - Verbose_level 3+ are used when trying to actively debug a problem.
*
* ring_name represent the name of the ring for which data collection shall start.
*
* flags: TBD parameter used to enable/disable specific events on a ring
* max_interval: maximum interval in seconds for driver to invoke on_ring_buffer_data,
* ignore if zero
* min_data_size: minimum data size in buffer for driver to invoke on_ring_buffer_data,
* ignore if zero
*/
wifi_error wifi_start_logging(wifi_interface_handle iface, u32 verbose_level, u32 flags,
u32 max_interval_sec, u32 min_data_size, char* ring_name);
/**
* API to get the status of all ring buffers supported by driver.
* - Caller is responsible to allocate / free ring buffer status.
* - Maximum no of ring buffer would be 10.
*/
wifi_error wifi_get_ring_buffers_status(wifi_interface_handle iface, u32* num_rings,
wifi_ring_buffer_status* status);
/**
* Synchronous memory dump by user request.
* - Caller is responsible to store memory dump data into a local,
* e.g., /data/misc/wifi/memdump.bin
*/
typedef struct {
void (*on_firmware_memory_dump)(char* buffer, int buffer_size);
} wifi_firmware_memory_dump_handler;
/**
* API to collect a firmware memory dump for a given iface by async memdump event.
* - Triggered by Alerthandler, esp. when FW problem or FW health check happens
* - Caller is responsible to store fw dump data into a local,
* e.g., /data/misc/wifi/alertdump-1.bin
*/
wifi_error wifi_get_firmware_memory_dump(wifi_interface_handle iface,
wifi_firmware_memory_dump_handler handler);
/**
* API to collect a firmware version string.
* - Caller is responsible to allocate / free a buffer to retrieve firmware verion info.
* - Max string will be at most 256 bytes.
*/
wifi_error wifi_get_firmware_version(wifi_interface_handle iface, char* buffer, int buffer_size);
/**
* API to collect a driver version string.
* - Caller is responsible to allocate / free a buffer to retrieve driver verion info.
* - Max string will be at most 256 bytes.
*/
wifi_error wifi_get_driver_version(wifi_interface_handle iface, char* buffer, int buffer_size);
/* Feature set */
enum {
WIFI_LOGGER_MEMORY_DUMP_SUPPORTED = (1 << (0)), // Memory dump of FW
WIFI_LOGGER_PER_PACKET_TX_RX_STATUS_SUPPORTED = (1 << (1)), // PKT status
WIFI_LOGGER_CONNECT_EVENT_SUPPORTED = (1 << (2)), // Connectivity event
WIFI_LOGGER_POWER_EVENT_SUPPORTED = (1 << (3)), // POWER of Driver
WIFI_LOGGER_WAKE_LOCK_SUPPORTED = (1 << (4)), // WAKE LOCK of Driver
WIFI_LOGGER_VERBOSE_SUPPORTED = (1 << (5)), // verbose log of FW
WIFI_LOGGER_WATCHDOG_TIMER_SUPPORTED = (1 << (6)), // monitor the health of FW
WIFI_LOGGER_DRIVER_DUMP_SUPPORTED = (1 << (7)), // dumps driver state
WIFI_LOGGER_PACKET_FATE_SUPPORTED = (1 << (8)), // tracks connection packets' fate
};
/**
* API to retrieve the current supportive features.
* - An integer variable is enough to have bit mapping info by caller.
*/
wifi_error wifi_get_logger_supported_feature_set(wifi_interface_handle iface,
unsigned int* support);
typedef struct {
/* Buffer is to be allocated and freed by HAL implementation. */
void (*on_driver_memory_dump)(char* buffer, int buffer_size);
} wifi_driver_memory_dump_callbacks;
/**
API to collect driver state.
Framework will call this API soon before or after (but not
concurrently with) wifi_get_firmware_memory_dump(). Capturing
firmware and driver dumps is intended to help identify
inconsistent state between these components.
- In response to this call, HAL implementation should make one or
more calls to callbacks.on_driver_memory_dump(). Framework will
copy data out of the received |buffer|s, and concatenate the
contents thereof.
- HAL implemention will indicate completion of the driver memory
dump by returning from this call.
*/
wifi_error wifi_get_driver_memory_dump(wifi_interface_handle iface,
wifi_driver_memory_dump_callbacks callbacks);
/* packet fate logs */
#define MD5_PREFIX_LEN 4
#define MAX_FATE_LOG_LEN 32
#define MAX_FRAME_LEN_ETHERNET 1518
#define MAX_FRAME_LEN_80211_MGMT 2352 // 802.11-2012 Fig. 8-34
typedef enum {
// Sent over air and ACKed.
TX_PKT_FATE_ACKED,
// Sent over air but not ACKed. (Normal for broadcast/multicast.)
TX_PKT_FATE_SENT,
// Queued within firmware, but not yet sent over air.
TX_PKT_FATE_FW_QUEUED,
// Dropped by firmware as invalid. E.g. bad source address, bad checksum,
// or invalid for current state.
TX_PKT_FATE_FW_DROP_INVALID,
// Dropped by firmware due to lack of buffer space.
TX_PKT_FATE_FW_DROP_NOBUFS,
// Dropped by firmware for any other reason. Includes frames that
// were sent by driver to firmware, but unaccounted for by
// firmware.
TX_PKT_FATE_FW_DROP_OTHER,
// Queued within driver, not yet sent to firmware.
TX_PKT_FATE_DRV_QUEUED,
// Dropped by driver as invalid. E.g. bad source address, or
// invalid for current state.
TX_PKT_FATE_DRV_DROP_INVALID,
// Dropped by driver due to lack of buffer space.
TX_PKT_FATE_DRV_DROP_NOBUFS,
// Dropped by driver for any other reason.
TX_PKT_FATE_DRV_DROP_OTHER,
} wifi_tx_packet_fate;
typedef enum {
// Valid and delivered to network stack (e.g., netif_rx()).
RX_PKT_FATE_SUCCESS,
// Queued within firmware, but not yet sent to driver.
RX_PKT_FATE_FW_QUEUED,
// Dropped by firmware due to host-programmable filters.
RX_PKT_FATE_FW_DROP_FILTER,
// Dropped by firmware as invalid. E.g. bad checksum, decrypt failed,
// or invalid for current state.
RX_PKT_FATE_FW_DROP_INVALID,
// Dropped by firmware due to lack of buffer space.
RX_PKT_FATE_FW_DROP_NOBUFS,
// Dropped by firmware for any other reason.
RX_PKT_FATE_FW_DROP_OTHER,
// Queued within driver, not yet delivered to network stack.
RX_PKT_FATE_DRV_QUEUED,
// Dropped by driver due to filter rules.
RX_PKT_FATE_DRV_DROP_FILTER,
// Dropped by driver as invalid. E.g. not permitted in current state.
RX_PKT_FATE_DRV_DROP_INVALID,
// Dropped by driver due to lack of buffer space.
RX_PKT_FATE_DRV_DROP_NOBUFS,
// Dropped by driver for any other reason.
RX_PKT_FATE_DRV_DROP_OTHER,
} wifi_rx_packet_fate;
typedef enum {
FRAME_TYPE_UNKNOWN,
FRAME_TYPE_ETHERNET_II,
FRAME_TYPE_80211_MGMT,
} frame_type;
typedef struct {
// The type of MAC-layer frame that this frame_info holds.
// - For data frames, use FRAME_TYPE_ETHERNET_II.
// - For management frames, use FRAME_TYPE_80211_MGMT.
// - If the type of the frame is unknown, use FRAME_TYPE_UNKNOWN.
frame_type payload_type;
// The number of bytes included in |frame_content|. If the frame
// contents are missing (e.g. RX frame dropped in firmware),
// |frame_len| should be set to 0.
size_t frame_len;
// Host clock when this frame was received by the driver (either
// outbound from the host network stack, or inbound from the
// firmware).
// - The timestamp should be taken from a clock which includes time
// the host spent suspended (e.g. ktime_get_boottime()).
// - If no host timestamp is available (e.g. RX frame was dropped in
// firmware), this field should be set to 0.
u32 driver_timestamp_usec;
// Firmware clock when this frame was received by the firmware
// (either outbound from the host, or inbound from a remote
// station).
// - The timestamp should be taken from a clock which includes time
// firmware spent suspended (if applicable).
// - If no firmware timestamp is available (e.g. TX frame was
// dropped by driver), this field should be set to 0.
// - Consumers of |frame_info| should _not_ assume any
// synchronization between driver and firmware clocks.
u32 firmware_timestamp_usec;
// Actual frame content.
// - Should be provided for TX frames originated by the host.
// - Should be provided for RX frames received by the driver.
// - Optionally provided for TX frames originated by firmware. (At
// discretion of HAL implementation.)
// - Optionally provided for RX frames dropped in firmware. (At
// discretion of HAL implementation.)
// - If frame content is not provided, |frame_len| should be set
// to 0.
union {
char ethernet_ii_bytes[MAX_FRAME_LEN_ETHERNET];
char ieee_80211_mgmt_bytes[MAX_FRAME_LEN_80211_MGMT];
} frame_content;
} frame_info;
typedef struct {
// Prefix of MD5 hash of |frame_inf.frame_content|. If frame
// content is not provided, prefix of MD5 hash over the same data
// that would be in frame_content, if frame content were provided.
char md5_prefix[MD5_PREFIX_LEN];
wifi_tx_packet_fate fate;
frame_info frame_inf;
} wifi_tx_report;
typedef struct {
// Prefix of MD5 hash of |frame_inf.frame_content|. If frame
// content is not provided, prefix of MD5 hash over the same data
// that would be in frame_content, if frame content were provided.
char md5_prefix[MD5_PREFIX_LEN];
wifi_rx_packet_fate fate;
frame_info frame_inf;
} wifi_rx_report;
/**
API to start packet fate monitoring.
- Once stared, monitoring should remain active until HAL is unloaded.
- When HAL is unloaded, all packet fate buffers should be cleared.
*/
wifi_error wifi_start_pkt_fate_monitoring(wifi_interface_handle handle);
/**
API to retrieve fates of outbound packets.
- HAL implementation should fill |tx_report_bufs| with fates of
_first_ min(n_requested_fates, actual packets) frames
transmitted for the most recent association. The fate reports
should follow the same order as their respective packets.
- HAL implementation may choose (but is not required) to include
reports for management frames.
- Packets reported by firmware, but not recognized by driver,
should be included. However, the ordering of the corresponding
reports is at the discretion of HAL implementation.
- Framework may call this API multiple times for the same association.
- Framework will ensure |n_requested_fates <= MAX_FATE_LOG_LEN|.
- Framework will allocate and free the referenced storage.
*/
wifi_error wifi_get_tx_pkt_fates(wifi_interface_handle handle, wifi_tx_report* tx_report_bufs,
size_t n_requested_fates, size_t* n_provided_fates);
/**
API to retrieve fates of inbound packets.
- HAL implementation should fill |rx_report_bufs| with fates of
_first_ min(n_requested_fates, actual packets) frames
received for the most recent association. The fate reports
should follow the same order as their respective packets.
- HAL implementation may choose (but is not required) to include
reports for management frames.
- Packets reported by firmware, but not recognized by driver,
should be included. However, the ordering of the corresponding
reports is at the discretion of HAL implementation.
- Framework may call this API multiple times for the same association.
- Framework will ensure |n_requested_fates <= MAX_FATE_LOG_LEN|.
- Framework will allocate and free the referenced storage.
*/
wifi_error wifi_get_rx_pkt_fates(wifi_interface_handle handle, wifi_rx_report* rx_report_bufs,
size_t n_requested_fates, size_t* n_provided_fates);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /*__WIFI_HAL_STATS_ */

2726
wifi/1.6/default/hal_legacy/wifi_nan.h
View File

File diff suppressed because it is too large Load Diff

30
wifi/1.6/default/hal_legacy/wifi_offload.h
View File

@@ -1,30 +0,0 @@
#include "wifi_hal.h"
#ifndef __WIFI_HAL_OFFLOAD_H
#define __WIFI_HAL_OFFLOAD_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define ETHER_ADDR_LEN 6 // Ethernet frame address length
#define N_AVAIL_ID 3 // available mkeep_alive IDs from 1 to 3
#define MKEEP_ALIVE_IP_PKT_MAX 256 // max size of IP packet for keep alive
/**
* Send specified keep alive packet periodically.
*/
wifi_error wifi_start_sending_offloaded_packet(wifi_request_id id, wifi_interface_handle iface,
u16 ether_type, u8* ip_packet, u16 ip_packet_len,
u8* src_mac_addr, u8* dst_mac_addr, u32 period_msec);
/**
* Stop sending keep alive packet.
*/
wifi_error wifi_stop_sending_offloaded_packet(wifi_request_id id, wifi_interface_handle iface);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /*__WIFI_HAL_OFFLOAD_H */

156
wifi/1.6/default/hal_legacy/wifi_twt.h
View File

@@ -1,156 +0,0 @@
/*
* Copyright (C) 2020 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_HAL_TWT_H__
#define __WIFI_HAL_TWT_H__
#include "wifi_hal.h"
typedef struct {
u8 requester_supported; // 0 for not supporting requester
u8 responder_supported; // 0 for not supporting responder
u8 broadcast_twt_supported; // 0 for not supporting broadcast TWT
u8 flexibile_twt_supported; // 0 for not supporting flexible TWT
} TwtCapability;
typedef struct {
TwtCapability device_capability;
TwtCapability peer_capability;
} TwtCapabilitySet;
// For all optional fields below, if no value specify -1
typedef struct {
u8 config_id; // An unique ID for an individual TWT request
u8 negotiation_type; // 0 for individual TWT, 1 for broadcast TWT
u8 trigger_type; // 0 for non-triggered TWT, 1 for triggered TWT
s32 wake_dur_us; // Proposed wake duration in us
s32 wake_int_us; // Average wake interval in us
s32 wake_int_min_us; // Min wake interval in us. Optional.
s32 wake_int_max_us; // Max wake interval in us. Optional.
s32 wake_dur_min_us; // Min wake duration in us. Optional.
s32 wake_dur_max_us; // Max wake duration in us. Optional.
s32 avg_pkt_size; // Average bytes of each packet to send in each wake
// duration. Optional.
s32 avg_pkt_num; // Average number of packets to send in each wake
// duration. Optional.
s32 wake_time_off_us; // First wake duration time offset in us. Optional.
} TwtSetupRequest;
typedef enum {
TWT_SETUP_SUCCESS = 0, // TWT setup is accepted.
TWT_SETUP_REJECT = 1, // TWT setup is rejected by AP.
TWT_SETUP_TIMEOUT = 2, // TWT setup response from AP times out.
TWT_SETUP_IE = 3, // AP sent TWT Setup IE parsing failure.
TWT_SETUP_PARAMS = 4, // AP sent TWT Setup IE Parameters invalid.
TWT_SETUP_ERROR = 255, // Generic error
} TwtSetupReasonCode;
typedef struct {
u8 config_id; // An unique ID for an individual TWT request
u8 status; // 0 for success, non-zero for failure
TwtSetupReasonCode reason_code;
u8 negotiation_type; // 0 for individual TWT, 1 for broadcast TWT
u8 trigger_type; // 0 for non-triggered TWT, 1 for triggered TWT
s32 wake_dur_us; // Proposed wake duration in us
s32 wake_int_us; // Average wake interval in us
s32 wake_time_off_us; // First wake duration time offset in us.
} TwtSetupResponse;
typedef struct {
u8 config_id; // An unique ID for an individual TWT request
u8 all_twt; // 0 for individual setp request, 1 for all TWT
u8 negotiation_type; // 0 for individual TWT, 1 for broadcast TWT
} TwtTeardownRequest;
typedef enum {
TWT_TD_RC_HOST = 0, // Teardown triggered by Host
TWT_TD_RC_PEER = 1, // Peer initiated teardown
TWT_TD_RC_MCHAN = 2, // Teardown due to MCHAN Active
TWT_TD_RC_MCNX = 3, // Teardown due to MultiConnection
TWT_TD_RC_CSA = 4, // Teardown due to CSA
TWT_TD_RC_BTCX = 5, // Teardown due to BT Coex
TWT_TD_RC_SETUP_FAIL = 6, // Setup fails midway. Teardown all connections
TWT_TD_RC_SCHED = 7, // Teardown by TWT Scheduler
TWT_TD_RC_ERROR = 255, // Generic error cases
} TwtTeardownReason;
typedef struct {
u8 config_id; // An unique ID for an individual TWT request
u8 all_twt; // 0 for individual setp request, 1 for all TWT
u8 status; // 0 for success, non-zero for failure
TwtTeardownReason reason;
} TwtTeardownCompletion;
typedef struct {
u8 config_id; // An unique ID for an individual TWT request
u8 all_twt; // 0 for individual setup request, 1 for all TWT
s32 resume_time_us; // If -1, TWT is suspended for indefinite time.
// Otherwise, TWT is suspended for resume_time_us
} TwtInfoFrameRequest;
typedef enum {
TWT_INFO_RC_HOST = 0, // Host initiated TWT Info frame */
TWT_INFO_RC_PEER = 1, // Peer initiated TWT Info frame
TWT_INFO_RC_ERROR = 2, // Generic error conditions */
} TwtInfoFrameReason;
// TWT Info frame triggered externally.
// Device should not send TwtInfoFrameReceived to Host for internally
// triggered TWT Info frame during SCAN, MCHAN operations.
typedef struct {
u8 config_id; // An unique ID for an individual TWT request
u8 all_twt; // 0 for individual setup request, 1 for all TWT
u8 status; // 0 for success, non-zero for failure
TwtInfoFrameReason reason;
u8 twt_resumed; // 1 - TWT resumed, 0 - TWT suspended
} TwtInfoFrameReceived;
typedef struct {
u8 config_id;
u32 avg_pkt_num_tx; // Average number of Tx packets in each wake duration.
u32 avg_pkt_num_rx; // Average number of Rx packets in each wake duration.
u32 avg_tx_pkt_size; // Average bytes per Rx packet in each wake duration.
u32 avg_rx_pkt_size; // Average bytes per Rx packet in each wake duration.
u32 avg_eosp_dur_us; // Average duration of early terminated SP
u32 eosp_count; // Count of early terminations
u32 num_sp; // Count of service period (SP), also known as wake duration.
} TwtStats;
// Asynchronous notification from the device.
// For example, TWT was torn down by the device and later when the device is
// ready, it can send this async notification.
// This can be expandable in future.
typedef enum {
TWT_NOTIF_ALLOW_TWT = 1, // Device ready to process TWT Setup request
} TwtNotification;
typedef struct {
TwtNotification notification;
} TwtDeviceNotify;
// Callbacks for various TWT responses and events
typedef struct {
// Callback for TWT setup response
void (*EventTwtSetupResponse)(TwtSetupResponse* event);
// Callback for TWT teardown completion
void (*EventTwtTeardownCompletion)(TwtTeardownCompletion* event);
// Callback for TWT info frame received event
void (*EventTwtInfoFrameReceived)(TwtInfoFrameReceived* event);
// Callback for TWT notification from the device
void (*EventTwtDeviceNotify)(TwtDeviceNotify* event);
} TwtCallbackHandler;
#endif /* __WIFI_HAL_TWT_H__ */

122
wifi/1.6/default/hidl_callback_util.h
View File

@@ -1,122 +0,0 @@
/*
* Copyright (C) 2017 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 HIDL_CALLBACK_UTIL_H_
#define HIDL_CALLBACK_UTIL_H_
#include <set>
#include <hidl/HidlSupport.h>
#include <hidl/HidlTransportSupport.h>
namespace {
// Type of callback invoked by the death handler.
using on_death_cb_function = std::function<void(uint64_t)>;
// Private class used to keep track of death of individual
// callbacks stored in HidlCallbackHandler.
template <typename CallbackType>
class HidlDeathHandler : public android::hardware::hidl_death_recipient {
public:
HidlDeathHandler(const on_death_cb_function& user_cb_function)
: cb_function_(user_cb_function) {}
~HidlDeathHandler() = default;
// Death notification for callbacks.
void serviceDied(uint64_t cookie,
const android::wp<android::hidl::base::V1_0::IBase>& /* who */) override {
cb_function_(cookie);
}
private:
on_death_cb_function cb_function_;
DISALLOW_COPY_AND_ASSIGN(HidlDeathHandler);
};
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_callback_util {
template <typename CallbackType>
// Provides a class to manage callbacks for the various HIDL interfaces and
// handle the death of the process hosting each callback.
class HidlCallbackHandler {
public:
HidlCallbackHandler()
: death_handler_(new HidlDeathHandler<CallbackType>(
std::bind(&HidlCallbackHandler::onObjectDeath, this, std::placeholders::_1))) {}
~HidlCallbackHandler() = default;
bool addCallback(const sp<CallbackType>& cb) {
// TODO(b/33818800): Can't compare proxies yet. So, use the cookie
// (callback proxy's raw pointer) to track the death of individual
// clients.
uint64_t cookie = reinterpret_cast<uint64_t>(cb.get());
for (const auto& s : cb_set_) {
if (interfacesEqual(cb, s)) {
LOG(ERROR) << "Duplicate death notification registration";
return true;
}
}
if (!cb->linkToDeath(death_handler_, cookie)) {
LOG(ERROR) << "Failed to register death notification";
return false;
}
cb_set_.insert(cb);
return true;
}
const std::set<android::sp<CallbackType>>& getCallbacks() { return cb_set_; }
// Death notification for callbacks.
void onObjectDeath(uint64_t cookie) {
CallbackType* cb = reinterpret_cast<CallbackType*>(cookie);
const auto& iter = cb_set_.find(cb);
if (iter == cb_set_.end()) {
LOG(ERROR) << "Unknown callback death notification received";
return;
}
cb_set_.erase(iter);
LOG(DEBUG) << "Dead callback removed from list";
}
void invalidate() {
for (const sp<CallbackType>& cb : cb_set_) {
if (!cb->unlinkToDeath(death_handler_)) {
LOG(ERROR) << "Failed to deregister death notification";
}
}
cb_set_.clear();
}
private:
std::set<sp<CallbackType>> cb_set_;
sp<HidlDeathHandler<CallbackType>> death_handler_;
DISALLOW_COPY_AND_ASSIGN(HidlCallbackHandler);
};
} // namespace hidl_callback_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_CALLBACK_UTIL_H_

118
wifi/1.6/default/hidl_return_util.h
View File

@@ -1,118 +0,0 @@
/*
* 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 HIDL_RETURN_UTIL_H_
#define HIDL_RETURN_UTIL_H_
#include "hidl_sync_util.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_return_util {
using namespace android::hardware::wifi::V1_0;
/**
* These utility functions are used to invoke a method on the provided
* HIDL interface object.
* These functions checks if the provided HIDL interface object is valid.
* a) if valid, Invokes the corresponding internal implementation function of
* the HIDL method. It then invokes the HIDL continuation callback with
* the status and any returned values.
* b) if invalid, invokes the HIDL continuation callback with the
* provided error status and default values.
*/
// Use for HIDL methods which return only an instance of WifiStatus.
template <typename ObjT, typename WorkFuncT, typename... Args>
Return<void> validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
const std::function<void(const WifiStatus&)>& hidl_cb,
Args&&... args) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
hidl_cb((obj->*work)(std::forward<Args>(args)...));
} else {
hidl_cb(createWifiStatus(status_code_if_invalid));
}
return Void();
}
// Use for HIDL methods which return only an instance of WifiStatus.
// This version passes the global lock acquired to the body of the method.
// Note: Only used by IWifi::stop() currently.
template <typename ObjT, typename WorkFuncT, typename... Args>
Return<void> validateAndCallWithLock(ObjT* obj, WifiStatusCode status_code_if_invalid,
WorkFuncT&& work,
const std::function<void(const WifiStatus&)>& hidl_cb,
Args&&... args) {
auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
hidl_cb((obj->*work)(&lock, std::forward<Args>(args)...));
} else {
hidl_cb(createWifiStatus(status_code_if_invalid));
}
return Void();
}
// Use for HIDL methods which return instance of WifiStatus and a single return
// value.
template <typename ObjT, typename WorkFuncT, typename ReturnT, typename... Args>
Return<void> validateAndCall(ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
const std::function<void(const WifiStatus&, ReturnT)>& hidl_cb,
Args&&... args) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
const auto& ret_pair = (obj->*work)(std::forward<Args>(args)...);
const WifiStatus& status = std::get<0>(ret_pair);
const auto& ret_value = std::get<1>(ret_pair);
hidl_cb(status, ret_value);
} else {
hidl_cb(createWifiStatus(status_code_if_invalid),
typename std::remove_reference<ReturnT>::type());
}
return Void();
}
// Use for HIDL methods which return instance of WifiStatus and 2 return
// values.
template <typename ObjT, typename WorkFuncT, typename ReturnT1, typename ReturnT2, typename... Args>
Return<void> validateAndCall(
ObjT* obj, WifiStatusCode status_code_if_invalid, WorkFuncT&& work,
const std::function<void(const WifiStatus&, ReturnT1, ReturnT2)>& hidl_cb, Args&&... args) {
const auto lock = hidl_sync_util::acquireGlobalLock();
if (obj->isValid()) {
const auto& ret_tuple = (obj->*work)(std::forward<Args>(args)...);
const WifiStatus& status = std::get<0>(ret_tuple);
const auto& ret_value1 = std::get<1>(ret_tuple);
const auto& ret_value2 = std::get<2>(ret_tuple);
hidl_cb(status, ret_value1, ret_value2);
} else {
hidl_cb(createWifiStatus(status_code_if_invalid),
typename std::remove_reference<ReturnT1>::type(),
typename std::remove_reference<ReturnT2>::type());
}
return Void();
}
} // namespace hidl_return_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_RETURN_UTIL_H_

3007
wifi/1.6/default/hidl_struct_util.cpp
View File

File diff suppressed because it is too large Load Diff

204
wifi/1.6/default/hidl_struct_util.h
View File

@@ -1,204 +0,0 @@
/*
* 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 HIDL_STRUCT_UTIL_H_
#define HIDL_STRUCT_UTIL_H_
#include <vector>
#include <android/hardware/wifi/1.0/IWifiChip.h>
#include <android/hardware/wifi/1.0/types.h>
#include <android/hardware/wifi/1.2/types.h>
#include <android/hardware/wifi/1.3/types.h>
#include <android/hardware/wifi/1.4/IWifiChipEventCallback.h>
#include <android/hardware/wifi/1.4/types.h>
#include <android/hardware/wifi/1.6/IWifiChip.h>
#include <android/hardware/wifi/1.6/types.h>
#include "wifi_legacy_hal.h"
/**
* This file contains a bunch of functions to convert structs from the legacy
* HAL to HIDL and vice versa.
* TODO(b/32093047): Add unit tests for these conversion methods in the VTS test
* suite.
*/
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_struct_util {
using namespace android::hardware::wifi::V1_0;
// Chip conversion methods.
bool convertLegacyFeaturesToHidlChipCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* hidl_caps);
bool convertLegacyDebugRingBufferStatusToHidl(
const legacy_hal::wifi_ring_buffer_status& legacy_status,
WifiDebugRingBufferStatus* hidl_status);
bool convertLegacyVectorOfDebugRingBufferStatusToHidl(
const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec,
std::vector<WifiDebugRingBufferStatus>* hidl_status_vec);
bool convertLegacyWakeReasonStatsToHidl(const legacy_hal::WakeReasonStats& legacy_stats,
WifiDebugHostWakeReasonStats* hidl_stats);
legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy(
V1_1::IWifiChip::TxPowerScenario hidl_scenario);
legacy_hal::wifi_latency_mode convertHidlLatencyModeToLegacy(
V1_3::IWifiChip::LatencyMode hidl_latency_mode);
legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy_1_2(
V1_2::IWifiChip::TxPowerScenario hidl_scenario);
bool convertLegacyWifiMacInfosToHidl(
const std::vector<legacy_hal::WifiMacInfo>& legacy_mac_infos,
std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo>* hidl_radio_mode_infos);
legacy_hal::wifi_interface_type convertHidlIfaceTypeToLegacy(IfaceType hidl_interface_type);
legacy_hal::wifi_multi_sta_use_case convertHidlMultiStaUseCaseToLegacy(
V1_5::IWifiChip::MultiStaUseCase use_case);
bool convertHidlCoexUnsafeChannelToLegacy(
const V1_5::IWifiChip::CoexUnsafeChannel& hidl_unsafe_channel,
legacy_hal::wifi_coex_unsafe_channel* legacy_unsafe_channel);
bool convertHidlVectorOfCoexUnsafeChannelToLegacy(
const std::vector<V1_5::IWifiChip::CoexUnsafeChannel>& hidl_unsafe_channels,
std::vector<legacy_hal::wifi_coex_unsafe_channel>* legacy_unsafe_channels);
bool convertLegacyRadioCombinationsMatrixToHidl(
legacy_hal::wifi_radio_combination_matrix* legacy_matrix,
V1_6::WifiRadioCombinationMatrix* hidl_matrix);
V1_5::WifiBand convertLegacyMacBandToHidlWifiBand(uint32_t band);
V1_6::WifiAntennaMode convertLegacyAntennaConfigurationToHidl(uint32_t antenna_cfg);
// STA iface conversion methods.
bool convertLegacyFeaturesToHidlStaCapabilities(uint64_t legacy_feature_set,
uint32_t legacy_logger_feature_set,
uint32_t* hidl_caps);
bool convertLegacyApfCapabilitiesToHidl(const legacy_hal::PacketFilterCapabilities& legacy_caps,
StaApfPacketFilterCapabilities* hidl_caps);
bool convertLegacyGscanCapabilitiesToHidl(const legacy_hal::wifi_gscan_capabilities& legacy_caps,
StaBackgroundScanCapabilities* hidl_caps);
legacy_hal::wifi_band convertHidlWifiBandToLegacy(V1_0::WifiBand band);
bool convertHidlGscanParamsToLegacy(const StaBackgroundScanParameters& hidl_scan_params,
legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
// Information Elements (IEs)
bool convertLegacyGscanResultToHidl(const legacy_hal::wifi_scan_result& legacy_scan_result,
bool has_ie_data, StaScanResult* hidl_scan_result);
// |cached_results| is assumed to not include IEs.
bool convertLegacyVectorOfCachedGscanResultsToHidl(
const std::vector<legacy_hal::wifi_cached_scan_results>& legacy_cached_scan_results,
std::vector<StaScanData>* hidl_scan_datas);
bool convertLegacyLinkLayerStatsToHidl(const legacy_hal::LinkLayerStats& legacy_stats,
V1_6::StaLinkLayerStats* hidl_stats);
bool convertLegacyRoamingCapabilitiesToHidl(
const legacy_hal::wifi_roaming_capabilities& legacy_caps,
StaRoamingCapabilities* hidl_caps);
bool convertHidlRoamingConfigToLegacy(const StaRoamingConfig& hidl_config,
legacy_hal::wifi_roaming_config* legacy_config);
legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(StaRoamingState state);
bool convertLegacyVectorOfDebugTxPacketFateToHidl(
const std::vector<legacy_hal::wifi_tx_report>& legacy_fates,
std::vector<WifiDebugTxPacketFateReport>* hidl_fates);
bool convertLegacyVectorOfDebugRxPacketFateToHidl(
const std::vector<legacy_hal::wifi_rx_report>& legacy_fates,
std::vector<WifiDebugRxPacketFateReport>* hidl_fates);
// NAN iface conversion methods.
void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len,
WifiNanStatus* wifiNanStatus);
bool convertHidlNanEnableRequestToLegacy(const V1_4::NanEnableRequest& hidl_request,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequestToLegacy(const V1_4::NanConfigRequest& hidl_request,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanEnableRequest_1_6ToLegacy(
const V1_4::NanEnableRequest& hidl_request1,
const V1_6::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanEnableRequest* legacy_request);
bool convertHidlNanConfigRequest_1_6ToLegacy(
const V1_4::NanConfigRequest& hidl_request1,
const V1_6::NanConfigRequestSupplemental& hidl_request2,
legacy_hal::NanConfigRequest* legacy_request);
bool convertHidlNanPublishRequestToLegacy(const V1_6::NanPublishRequest& hidl_request,
legacy_hal::NanPublishRequest* legacy_request);
bool convertHidlNanSubscribeRequestToLegacy(const V1_0::NanSubscribeRequest& hidl_request,
legacy_hal::NanSubscribeRequest* legacy_request);
bool convertHidlNanTransmitFollowupRequestToLegacy(
const NanTransmitFollowupRequest& hidl_request,
legacy_hal::NanTransmitFollowupRequest* legacy_request);
bool convertHidlNanDataPathInitiatorRequestToLegacy(
const V1_0::NanInitiateDataPathRequest& hidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertHidlNanDataPathIndicationResponseToLegacy(
const V1_0::NanRespondToDataPathIndicationRequest& hidl_response,
legacy_hal::NanDataPathIndicationResponse* legacy_response);
bool convertHidlNanDataPathInitiatorRequest_1_6ToLegacy(
const V1_6::NanInitiateDataPathRequest& hidl_request,
legacy_hal::NanDataPathInitiatorRequest* legacy_request);
bool convertHidlNanDataPathIndicationResponse_1_6ToLegacy(
const V1_6::NanRespondToDataPathIndicationRequest& hidl_response,
legacy_hal::NanDataPathIndicationResponse* legacy_response);
bool convertLegacyNanResponseHeaderToHidl(const legacy_hal::NanResponseMsg& legacy_response,
WifiNanStatus* wifiNanStatus);
bool convertLegacyNanCapabilitiesResponseToHidl(const legacy_hal::NanCapabilities& legacy_response,
V1_6::NanCapabilities* hidl_response);
bool convertLegacyNanMatchIndToHidl(const legacy_hal::NanMatchInd& legacy_ind,
V1_6::NanMatchInd* hidl_ind);
bool convertLegacyNanFollowupIndToHidl(const legacy_hal::NanFollowupInd& legacy_ind,
NanFollowupReceivedInd* hidl_ind);
bool convertLegacyNanDataPathRequestIndToHidl(const legacy_hal::NanDataPathRequestInd& legacy_ind,
NanDataPathRequestInd* hidl_ind);
bool convertLegacyNanDataPathConfirmIndToHidl(const legacy_hal::NanDataPathConfirmInd& legacy_ind,
V1_6::NanDataPathConfirmInd* hidl_ind);
bool convertLegacyNanDataPathScheduleUpdateIndToHidl(
const legacy_hal::NanDataPathScheduleUpdateInd& legacy_ind,
V1_6::NanDataPathScheduleUpdateInd* hidl_ind);
// RTT controller conversion methods.
bool convertHidlVectorOfRttConfigToLegacy(const std::vector<V1_6::RttConfig>& hidl_configs,
std::vector<legacy_hal::wifi_rtt_config>* legacy_configs);
bool convertHidlRttLciInformationToLegacy(const RttLciInformation& hidl_info,
legacy_hal::wifi_lci_information* legacy_info);
bool convertHidlRttLcrInformationToLegacy(const RttLcrInformation& hidl_info,
legacy_hal::wifi_lcr_information* legacy_info);
bool convertHidlRttResponderToLegacy(const V1_6::RttResponder& hidl_responder,
legacy_hal::wifi_rtt_responder* legacy_responder);
bool convertHidlWifiChannelInfoToLegacy(const V1_6::WifiChannelInfo& hidl_info,
legacy_hal::wifi_channel_info* legacy_info);
bool convertLegacyRttResponderToHidl(const legacy_hal::wifi_rtt_responder& legacy_responder,
V1_6::RttResponder* hidl_responder);
bool convertLegacyRttCapabilitiesToHidl(
const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,
V1_6::RttCapabilities* hidl_capabilities);
bool convertLegacyVectorOfRttResultToHidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
std::vector<V1_6::RttResult>* hidl_results);
uint32_t convertHidlWifiBandToLegacyMacBand(V1_5::WifiBand band);
uint32_t convertHidlWifiIfaceModeToLegacy(uint32_t hidl_iface_mask);
uint32_t convertHidlUsableChannelFilterToLegacy(uint32_t hidl_filter_mask);
bool convertLegacyWifiUsableChannelsToHidl(
const std::vector<legacy_hal::wifi_usable_channel>& legacy_usable_channels,
std::vector<V1_6::WifiUsableChannel>* hidl_usable_channels);
bool convertLegacyPeerInfoStatsToHidl(const legacy_hal::WifiPeerInfo& legacy_peer_info_stats,
V1_6::StaPeerInfo* hidl_peer_info_stats);
bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate,
V1_6::WifiRateInfo* hidl_rate);
} // namespace hidl_struct_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_STRUCT_UTIL_H_

39
wifi/1.6/default/hidl_sync_util.cpp
View File

@@ -1,39 +0,0 @@
/*
* 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.
*/
#include "hidl_sync_util.h"
namespace {
std::recursive_mutex g_mutex;
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_sync_util {
std::unique_lock<std::recursive_mutex> acquireGlobalLock() {
return std::unique_lock<std::recursive_mutex>{g_mutex};
}
} // namespace hidl_sync_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

37
wifi/1.6/default/hidl_sync_util.h
View File

@@ -1,37 +0,0 @@
/*
* 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 HIDL_SYNC_UTIL_H_
#define HIDL_SYNC_UTIL_H_
#include <mutex>
// Utility that provides a global lock to synchronize access between
// the HIDL thread and the legacy HAL's event loop.
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace hidl_sync_util {
std::unique_lock<std::recursive_mutex> acquireGlobalLock();
} // namespace hidl_sync_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // HIDL_SYNC_UTIL_H_

64
wifi/1.6/default/ringbuffer.cpp
View File

@@ -1,64 +0,0 @@
/*
* Copyright (C) 2018 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.
*/
#include <android-base/logging.h>
#include "ringbuffer.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
Ringbuffer::Ringbuffer(size_t maxSize) : size_(0), maxSize_(maxSize) {}
enum Ringbuffer::AppendStatus Ringbuffer::append(const std::vector<uint8_t>& input) {
if (input.size() == 0) {
return AppendStatus::FAIL_IP_BUFFER_ZERO;
}
if (input.size() > maxSize_) {
LOG(INFO) << "Oversized message of " << input.size() << " bytes is dropped";
return AppendStatus::FAIL_IP_BUFFER_EXCEEDED_MAXSIZE;
}
data_.push_back(input);
size_ += input.size() * sizeof(input[0]);
while (size_ > maxSize_) {
if (data_.front().size() <= 0 || data_.front().size() > maxSize_) {
LOG(ERROR) << "First buffer in the ring buffer is Invalid. Size: "
<< data_.front().size();
return AppendStatus::FAIL_RING_BUFFER_CORRUPTED;
}
size_ -= data_.front().size() * sizeof(data_.front()[0]);
data_.pop_front();
}
return AppendStatus::SUCCESS;
}
const std::list<std::vector<uint8_t>>& Ringbuffer::getData() const {
return data_;
}
void Ringbuffer::clear() {
data_.clear();
size_ = 0;
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

62
wifi/1.6/default/ringbuffer.h
View File

@@ -1,62 +0,0 @@
/*
* Copyright (C) 2018 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 RINGBUFFER_H_
#define RINGBUFFER_H_
#include <list>
#include <vector>
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
/**
* Ringbuffer object used to store debug data.
*/
class Ringbuffer {
public:
// Error codes for the append ring buffer operation
enum AppendStatus {
SUCCESS,
FAIL_GENERIC,
FAIL_IP_BUFFER_ZERO,
FAIL_IP_BUFFER_EXCEEDED_MAXSIZE,
FAIL_RING_BUFFER_CORRUPTED
};
explicit Ringbuffer(size_t maxSize);
// Appends the data buffer and deletes from the front until buffer is
// within |maxSize_|.
enum AppendStatus append(const std::vector<uint8_t>& input);
const std::list<std::vector<uint8_t>>& getData() const;
void clear();
private:
std::list<std::vector<uint8_t>> data_;
size_t size_;
size_t maxSize_;
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // RINGBUFFER_H_

71
wifi/1.6/default/service.cpp
View File

@@ -1,71 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include <hidl/HidlLazyUtils.h>
#include <hidl/HidlTransportSupport.h>
#include <signal.h>
#include <utils/Looper.h>
#include <utils/StrongPointer.h>
#include "wifi.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_factory.h"
#include "wifi_mode_controller.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::LazyServiceRegistrar;
using android::hardware::wifi::V1_6::implementation::feature_flags::WifiFeatureFlags;
using android::hardware::wifi::V1_6::implementation::legacy_hal::WifiLegacyHal;
using android::hardware::wifi::V1_6::implementation::legacy_hal::WifiLegacyHalFactory;
using android::hardware::wifi::V1_6::implementation::mode_controller::WifiModeController;
#ifdef LAZY_SERVICE
const bool kLazyService = true;
#else
const bool kLazyService = false;
#endif
int main(int /*argc*/, char** argv) {
signal(SIGPIPE, SIG_IGN);
android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
LOG(INFO) << "Wifi Hal is booting up...";
configureRpcThreadpool(1, true /* callerWillJoin */);
const auto iface_tool = std::make_shared<android::wifi_system::InterfaceTool>();
const auto legacy_hal_factory = std::make_shared<WifiLegacyHalFactory>(iface_tool);
// Setup hwbinder service
android::sp<android::hardware::wifi::V1_6::IWifi> service =
new android::hardware::wifi::V1_6::implementation::Wifi(
iface_tool, legacy_hal_factory, std::make_shared<WifiModeController>(),
std::make_shared<WifiFeatureFlags>());
if (kLazyService) {
auto registrar = LazyServiceRegistrar::getInstance();
CHECK_EQ(registrar.registerService(service), android::NO_ERROR)
<< "Failed to register wifi HAL";
} else {
CHECK_EQ(service->registerAsService(), android::NO_ERROR) << "Failed to register wifi HAL";
}
joinRpcThreadpool();
LOG(INFO) << "Wifi Hal is terminating...";
return 0;
}

486
wifi/1.6/default/tests/hidl_struct_util_unit_tests.cpp
View File

@@ -1,486 +0,0 @@
/*
* Copyright (C) 2017, 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN
#include "hidl_struct_util.h"
using testing::Test;
namespace {
constexpr uint32_t kMacId1 = 1;
constexpr uint32_t kMacId2 = 2;
constexpr uint32_t kIfaceChannel1 = 3;
constexpr uint32_t kIfaceChannel2 = 5;
constexpr char kIfaceName1[] = "wlan0";
constexpr char kIfaceName2[] = "wlan1";
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using ::android::hardware::wifi::V1_6::WifiChannelWidthInMhz;
class HidlStructUtilTest : public Test {};
TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithOneMac) {
std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
legacy_hal::WifiMacInfo legacy_mac_info1 = {
.wlan_mac_id = kMacId1,
.mac_band = legacy_hal::WLAN_MAC_5_0_BAND | legacy_hal::WLAN_MAC_2_4_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1, .channel = kIfaceChannel1};
legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2, .channel = kIfaceChannel2};
legacy_mac_info1.iface_infos.push_back(legacy_iface_info1);
legacy_mac_info1.iface_infos.push_back(legacy_iface_info2);
legacy_mac_infos.push_back(legacy_mac_info1);
std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
&hidl_radio_mode_infos));
ASSERT_EQ(1u, hidl_radio_mode_infos.size());
auto hidl_radio_mode_info1 = hidl_radio_mode_infos[0];
EXPECT_EQ(legacy_mac_info1.wlan_mac_id, hidl_radio_mode_info1.radioId);
EXPECT_EQ(V1_4::WifiBand::BAND_24GHZ_5GHZ, hidl_radio_mode_info1.bandInfo);
ASSERT_EQ(2u, hidl_radio_mode_info1.ifaceInfos.size());
auto hidl_iface_info1 = hidl_radio_mode_info1.ifaceInfos[0];
EXPECT_EQ(legacy_iface_info1.name, hidl_iface_info1.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_iface_info1.channel);
auto hidl_iface_info2 = hidl_radio_mode_info1.ifaceInfos[1];
EXPECT_EQ(legacy_iface_info2.name, hidl_iface_info2.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
}
TEST_F(HidlStructUtilTest, CanConvertLegacyWifiMacInfosToHidlWithTwoMac) {
std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
legacy_hal::WifiMacInfo legacy_mac_info1 = {.wlan_mac_id = kMacId1,
.mac_band = legacy_hal::WLAN_MAC_5_0_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1, .channel = kIfaceChannel1};
legacy_hal::WifiMacInfo legacy_mac_info2 = {.wlan_mac_id = kMacId2,
.mac_band = legacy_hal::WLAN_MAC_2_4_BAND};
legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2, .channel = kIfaceChannel2};
legacy_mac_info1.iface_infos.push_back(legacy_iface_info1);
legacy_mac_infos.push_back(legacy_mac_info1);
legacy_mac_info2.iface_infos.push_back(legacy_iface_info2);
legacy_mac_infos.push_back(legacy_mac_info2);
std::vector<V1_4::IWifiChipEventCallback::RadioModeInfo> hidl_radio_mode_infos;
ASSERT_TRUE(hidl_struct_util::convertLegacyWifiMacInfosToHidl(legacy_mac_infos,
&hidl_radio_mode_infos));
ASSERT_EQ(2u, hidl_radio_mode_infos.size());
// Find mac info 1.
const auto hidl_radio_mode_info1 =
std::find_if(hidl_radio_mode_infos.begin(), hidl_radio_mode_infos.end(),
[&legacy_mac_info1](const V1_4::IWifiChipEventCallback::RadioModeInfo& x) {
return x.radioId == legacy_mac_info1.wlan_mac_id;
});
ASSERT_NE(hidl_radio_mode_infos.end(), hidl_radio_mode_info1);
EXPECT_EQ(V1_4::WifiBand::BAND_5GHZ, hidl_radio_mode_info1->bandInfo);
ASSERT_EQ(1u, hidl_radio_mode_info1->ifaceInfos.size());
auto hidl_iface_info1 = hidl_radio_mode_info1->ifaceInfos[0];
EXPECT_EQ(legacy_iface_info1.name, hidl_iface_info1.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info1.channel), hidl_iface_info1.channel);
// Find mac info 2.
const auto hidl_radio_mode_info2 =
std::find_if(hidl_radio_mode_infos.begin(), hidl_radio_mode_infos.end(),
[&legacy_mac_info2](const V1_4::IWifiChipEventCallback::RadioModeInfo& x) {
return x.radioId == legacy_mac_info2.wlan_mac_id;
});
ASSERT_NE(hidl_radio_mode_infos.end(), hidl_radio_mode_info2);
EXPECT_EQ(V1_4::WifiBand::BAND_24GHZ, hidl_radio_mode_info2->bandInfo);
ASSERT_EQ(1u, hidl_radio_mode_info2->ifaceInfos.size());
auto hidl_iface_info2 = hidl_radio_mode_info2->ifaceInfos[0];
EXPECT_EQ(legacy_iface_info2.name, hidl_iface_info2.name);
EXPECT_EQ(static_cast<uint32_t>(legacy_iface_info2.channel), hidl_iface_info2.channel);
}
TEST_F(HidlStructUtilTest, canConvertLegacyLinkLayerStatsToHidl) {
legacy_hal::LinkLayerStats legacy_stats{};
legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
legacy_stats.peers.push_back(legacy_hal::WifiPeerInfo{});
legacy_stats.peers.push_back(legacy_hal::WifiPeerInfo{});
legacy_stats.iface.beacon_rx = rand();
legacy_stats.iface.rssi_mgmt = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg = rand();
legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples = rand();
legacy_stats.iface.info.time_slicing_duty_cycle_percent = rand();
legacy_stats.iface.num_peers = 1;
for (auto& radio : legacy_stats.radios) {
radio.stats.radio = rand();
radio.stats.on_time = rand();
radio.stats.tx_time = rand();
radio.stats.rx_time = rand();
radio.stats.on_time_scan = rand();
radio.stats.on_time_nbd = rand();
radio.stats.on_time_gscan = rand();
radio.stats.on_time_roam_scan = rand();
radio.stats.on_time_pno_scan = rand();
radio.stats.on_time_hs20 = rand();
for (int i = 0; i < 4; i++) {
radio.tx_time_per_levels.push_back(rand());
}
legacy_hal::wifi_channel_stat channel_stat1 = {
.channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 2437, 2437, 0},
.on_time = 0x1111,
.cca_busy_time = 0x55,
};
legacy_hal::wifi_channel_stat channel_stat2 = {
.channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 5180, 5180, 0},
.on_time = 0x2222,
.cca_busy_time = 0x66,
};
radio.channel_stats.push_back(channel_stat1);
radio.channel_stats.push_back(channel_stat2);
}
for (auto& peer : legacy_stats.peers) {
peer.peer_info.bssload.sta_count = rand();
peer.peer_info.bssload.chan_util = rand();
wifi_rate_stat rate_stat1 = {
.rate = {3, 1, 2, 5, 0, 0},
.tx_mpdu = 0,
.rx_mpdu = 1,
.mpdu_lost = 2,
.retries = 3,
.retries_short = 4,
.retries_long = 5,
};
wifi_rate_stat rate_stat2 = {
.rate = {2, 2, 1, 6, 0, 1},
.tx_mpdu = 6,
.rx_mpdu = 7,
.mpdu_lost = 8,
.retries = 9,
.retries_short = 10,
.retries_long = 11,
};
peer.rate_stats.push_back(rate_stat1);
peer.rate_stats.push_back(rate_stat2);
}
V1_6::StaLinkLayerStats converted{};
hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats, &converted);
EXPECT_EQ(legacy_stats.iface.beacon_rx, converted.iface.V1_0.beaconRx);
EXPECT_EQ(legacy_stats.iface.rssi_mgmt, converted.iface.V1_0.avgRssiMgmt);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu,
converted.iface.V1_0.wmeBePktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu,
converted.iface.V1_0.wmeBePktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost,
converted.iface.V1_0.wmeBePktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries,
converted.iface.V1_0.wmeBePktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min,
converted.iface.wmeBeContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max,
converted.iface.wmeBeContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg,
converted.iface.wmeBeContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
converted.iface.wmeBeContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu,
converted.iface.V1_0.wmeBkPktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu,
converted.iface.V1_0.wmeBkPktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost,
converted.iface.V1_0.wmeBkPktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries,
converted.iface.V1_0.wmeBkPktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min,
converted.iface.wmeBkContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max,
converted.iface.wmeBkContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg,
converted.iface.wmeBkContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
converted.iface.wmeBkContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu,
converted.iface.V1_0.wmeViPktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu,
converted.iface.V1_0.wmeViPktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost,
converted.iface.V1_0.wmeViPktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries,
converted.iface.V1_0.wmeViPktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min,
converted.iface.wmeViContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max,
converted.iface.wmeViContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg,
converted.iface.wmeViContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
converted.iface.wmeViContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu,
converted.iface.V1_0.wmeVoPktStats.rxMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu,
converted.iface.V1_0.wmeVoPktStats.txMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost,
converted.iface.V1_0.wmeVoPktStats.lostMpdu);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries,
converted.iface.V1_0.wmeVoPktStats.retries);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min,
converted.iface.wmeVoContentionTimeStats.contentionTimeMinInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max,
converted.iface.wmeVoContentionTimeStats.contentionTimeMaxInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg,
converted.iface.wmeVoContentionTimeStats.contentionTimeAvgInUsec);
EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
converted.iface.wmeVoContentionTimeStats.contentionNumSamples);
EXPECT_EQ(legacy_stats.iface.info.time_slicing_duty_cycle_percent,
converted.iface.timeSliceDutyCycleInPercent);
EXPECT_EQ(legacy_stats.radios.size(), converted.radios.size());
for (size_t i = 0; i < legacy_stats.radios.size(); i++) {
EXPECT_EQ(legacy_stats.radios[i].stats.radio, converted.radios[i].radioId);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time, converted.radios[i].V1_0.onTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, converted.radios[i].V1_0.txTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, converted.radios[i].V1_0.rxTimeInMs);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_scan,
converted.radios[i].V1_0.onTimeInMsForScan);
EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels.size(),
converted.radios[i].V1_0.txTimeInMsPerLevel.size());
for (size_t j = 0; j < legacy_stats.radios[i].tx_time_per_levels.size(); j++) {
EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels[j],
converted.radios[i].V1_0.txTimeInMsPerLevel[j]);
}
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_nbd,
converted.radios[i].onTimeInMsForNanScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_gscan,
converted.radios[i].onTimeInMsForBgScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_roam_scan,
converted.radios[i].onTimeInMsForRoamScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_pno_scan,
converted.radios[i].onTimeInMsForPnoScan);
EXPECT_EQ(legacy_stats.radios[i].stats.on_time_hs20,
converted.radios[i].onTimeInMsForHs20Scan);
EXPECT_EQ(legacy_stats.radios[i].channel_stats.size(),
converted.radios[i].channelStats.size());
for (size_t k = 0; k < legacy_stats.radios[i].channel_stats.size(); k++) {
auto& legacy_channel_st = legacy_stats.radios[i].channel_stats[k];
EXPECT_EQ(WifiChannelWidthInMhz::WIDTH_20,
converted.radios[i].channelStats[k].channel.width);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq),
converted.radios[i].channelStats[k].channel.centerFreq);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq0),
converted.radios[i].channelStats[k].channel.centerFreq0);
EXPECT_EQ(WifiChannelInMhz(legacy_channel_st.channel.center_freq1),
converted.radios[i].channelStats[k].channel.centerFreq1);
EXPECT_EQ(legacy_channel_st.cca_busy_time,
converted.radios[i].channelStats[k].ccaBusyTimeInMs);
EXPECT_EQ(legacy_channel_st.on_time, converted.radios[i].channelStats[k].onTimeInMs);
}
}
EXPECT_EQ(legacy_stats.peers.size(), converted.iface.peers.size());
for (size_t i = 0; i < legacy_stats.peers.size(); i++) {
EXPECT_EQ(legacy_stats.peers[i].peer_info.bssload.sta_count,
converted.iface.peers[i].staCount);
EXPECT_EQ(legacy_stats.peers[i].peer_info.bssload.chan_util,
converted.iface.peers[i].chanUtil);
for (size_t j = 0; j < legacy_stats.peers[i].rate_stats.size(); j++) {
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.preamble,
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.preamble);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.nss,
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.nss);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.bw,
(uint32_t)converted.iface.peers[i].rateStats[j].rateInfo.bw);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.rateMcsIdx,
converted.iface.peers[i].rateStats[j].rateInfo.rateMcsIdx);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].tx_mpdu,
converted.iface.peers[i].rateStats[j].txMpdu);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rx_mpdu,
converted.iface.peers[i].rateStats[j].rxMpdu);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].mpdu_lost,
converted.iface.peers[i].rateStats[j].mpduLost);
EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].retries,
converted.iface.peers[i].rateStats[j].retries);
}
}
}
TEST_F(HidlStructUtilTest, CanConvertLegacyFeaturesToHidl) {
using HidlChipCaps = V1_3::IWifiChip::ChipCapabilityMask;
uint32_t hidle_caps;
uint32_t legacy_feature_set = WIFI_FEATURE_D2D_RTT | WIFI_FEATURE_SET_LATENCY_MODE;
uint32_t legacy_logger_feature_set = legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED;
ASSERT_TRUE(hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
legacy_feature_set, legacy_logger_feature_set, &hidle_caps));
EXPECT_EQ(HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA |
HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS |
HidlChipCaps::DEBUG_ERROR_ALERTS | HidlChipCaps::D2D_RTT |
HidlChipCaps::SET_LATENCY_MODE | HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP,
hidle_caps);
}
void insertRadioCombination(legacy_hal::wifi_radio_combination* dst_radio_combination_ptr,
int num_radio_configurations,
legacy_hal::wifi_radio_configuration* radio_configuration) {
dst_radio_combination_ptr->num_radio_configurations = num_radio_configurations;
memcpy(dst_radio_combination_ptr->radio_configurations, radio_configuration,
num_radio_configurations * sizeof(legacy_hal::wifi_radio_configuration));
}
void verifyRadioCombination(WifiRadioCombination* radioCombination, size_t num_radio_configurations,
legacy_hal::wifi_radio_configuration* radio_configuration) {
EXPECT_EQ(num_radio_configurations, radioCombination->radioConfigurations.size());
for (size_t i = 0; i < num_radio_configurations; i++) {
EXPECT_EQ(hidl_struct_util::convertLegacyMacBandToHidlWifiBand(radio_configuration->band),
radioCombination->radioConfigurations[i].bandInfo);
EXPECT_EQ(hidl_struct_util::convertLegacyAntennaConfigurationToHidl(
radio_configuration->antenna_cfg),
radioCombination->radioConfigurations[i].antennaMode);
radio_configuration++;
}
}
TEST_F(HidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToHidl) {
legacy_hal::wifi_radio_configuration radio_configurations_array1[] = {
{.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_1X1},
};
legacy_hal::wifi_radio_configuration radio_configurations_array2[] = {
{.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_2X2},
{.band = legacy_hal::WLAN_MAC_5_0_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_3X3},
};
legacy_hal::wifi_radio_configuration radio_configurations_array3[] = {
{.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_2X2},
{.band = legacy_hal::WLAN_MAC_6_0_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_1X1},
{.band = legacy_hal::WLAN_MAC_5_0_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_4X4},
};
int num_radio_configs = 0;
int num_combinations = 0;
std::array<char, 256> buffer;
buffer.fill(0);
legacy_hal::wifi_radio_combination_matrix* legacy_matrix =
reinterpret_cast<wifi_radio_combination_matrix*>(buffer.data());
legacy_hal::wifi_radio_combination* radio_combinations;
// Prepare a legacy wifi_radio_combination_matrix
legacy_matrix->num_radio_combinations = 3;
// Insert first combination
radio_combinations =
(legacy_hal::wifi_radio_combination*)((char*)legacy_matrix->radio_combinations);
insertRadioCombination(
radio_combinations,
sizeof(radio_configurations_array1) / sizeof(radio_configurations_array1[0]),
radio_configurations_array1);
num_combinations++;
num_radio_configs +=
sizeof(radio_configurations_array1) / sizeof(radio_configurations_array1[0]);
// Insert second combination
radio_combinations =
(legacy_hal::wifi_radio_combination*)((char*)legacy_matrix->radio_combinations +
(num_combinations *
sizeof(legacy_hal::wifi_radio_combination)) +
(num_radio_configs *
sizeof(wifi_radio_configuration)));
insertRadioCombination(
radio_combinations,
sizeof(radio_configurations_array2) / sizeof(radio_configurations_array2[0]),
radio_configurations_array2);
num_combinations++;
num_radio_configs +=
sizeof(radio_configurations_array2) / sizeof(radio_configurations_array2[0]);
// Insert third combination
radio_combinations =
(legacy_hal::wifi_radio_combination*)((char*)legacy_matrix->radio_combinations +
(num_combinations *
sizeof(legacy_hal::wifi_radio_combination)) +
(num_radio_configs *
sizeof(wifi_radio_configuration)));
insertRadioCombination(
radio_combinations,
sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
radio_configurations_array3);
V1_6::WifiRadioCombinationMatrix converted_matrix{};
hidl_struct_util::convertLegacyRadioCombinationsMatrixToHidl(legacy_matrix, &converted_matrix);
// Verify the conversion
EXPECT_EQ(legacy_matrix->num_radio_combinations, converted_matrix.radioCombinations.size());
verifyRadioCombination(
&converted_matrix.radioCombinations[0],
sizeof(radio_configurations_array1) / sizeof(radio_configurations_array1[0]),
radio_configurations_array1);
verifyRadioCombination(
&converted_matrix.radioCombinations[1],
sizeof(radio_configurations_array2) / sizeof(radio_configurations_array2[0]),
radio_configurations_array2);
verifyRadioCombination(
&converted_matrix.radioCombinations[2],
sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
radio_configurations_array3);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

28
wifi/1.6/default/tests/main.cpp
View File

@@ -1,28 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <android-base/logging.h>
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleMock(&argc, argv);
// Force ourselves to always log to stderr
android::base::InitLogging(argv, android::base::StderrLogger);
return RUN_ALL_TESTS();
}

29
wifi/1.6/default/tests/mock_interface_tool.cpp
View File

@@ -1,29 +0,0 @@
/*
* Copyright (C) 2019 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_interface_tool.h"
namespace android {
namespace wifi_system {
MockInterfaceTool::MockInterfaceTool() {}
} // namespace wifi_system
} // namespace android

42
wifi/1.6/default/tests/mock_interface_tool.h
View File

@@ -1,42 +0,0 @@
/*
* Copyright (C) 2019 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 MOCK_INTERFACE_TOOL_H
#define MOCK_INTERFACE_TOOL_H
#include <gmock/gmock.h>
#include <wifi_system/interface_tool.h>
namespace android {
namespace wifi_system {
class MockInterfaceTool : public InterfaceTool {
public:
MockInterfaceTool();
MOCK_METHOD1(GetUpState, bool(const char* if_name));
MOCK_METHOD2(SetUpState, bool(const char* if_name, bool request_up));
MOCK_METHOD1(SetWifiUpState, bool(bool request_up));
MOCK_METHOD2(SetMacAddress,
bool(const char* if_name, const std::array<uint8_t, ETH_ALEN>& address));
MOCK_METHOD1(GetFactoryMacAddress, std::array<uint8_t, ETH_ALEN>(const char* if_name));
}; // class MockInterfaceTool
} // namespace wifi_system
} // namespace android
#endif // MOCK_INTERFACE_TOOL_H

35
wifi/1.6/default/tests/mock_wifi_feature_flags.cpp
View File

@@ -1,35 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#include <gmock/gmock.h>
#include "mock_wifi_feature_flags.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
MockWifiFeatureFlags::MockWifiFeatureFlags() {}
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

47
wifi/1.6/default/tests/mock_wifi_feature_flags.h
View File

@@ -1,47 +0,0 @@
/*
* Copyright (C) 2017 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 MOCK_WIFI_FEATURE_FLAGS_H_
#define MOCK_WIFI_FEATURE_FLAGS_H_
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "wifi_feature_flags.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
class MockWifiFeatureFlags : public WifiFeatureFlags {
public:
MockWifiFeatureFlags();
MOCK_METHOD1(getChipModes, std::vector<V1_6::IWifiChip::ChipMode>(bool is_primary));
MOCK_METHOD0(isApMacRandomizationDisabled, bool());
};
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // MOCK_WIFI_FEATURE_FLAGS_H_

39
wifi/1.6/default/tests/mock_wifi_iface_util.cpp
View File

@@ -1,39 +0,0 @@
/*
* Copyright (C) 2019 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_wifi_iface_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
MockWifiIfaceUtil::MockWifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: WifiIfaceUtil(iface_tool, legacy_hal) {}
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

50
wifi/1.6/default/tests/mock_wifi_iface_util.h
View File

@@ -1,50 +0,0 @@
/*
* Copyright (C) 2019 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 MOCK_WIFI_IFACE_UTIL_H_
#define MOCK_WIFI_IFACE_UTIL_H_
#include <gmock/gmock.h>
#include "wifi_iface_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
class MockWifiIfaceUtil : public WifiIfaceUtil {
public:
MockWifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
MOCK_METHOD1(getFactoryMacAddress, std::array<uint8_t, 6>(const std::string&));
MOCK_METHOD2(setMacAddress, bool(const std::string&, const std::array<uint8_t, 6>&));
MOCK_METHOD0(getOrCreateRandomMacAddress, std::array<uint8_t, 6>());
MOCK_METHOD2(registerIfaceEventHandlers, void(const std::string&, IfaceEventHandlers));
MOCK_METHOD1(unregisterIfaceEventHandlers, void(const std::string&));
MOCK_METHOD2(setUpState, bool(const std::string&, bool));
MOCK_METHOD1(ifNameToIndex, unsigned(const std::string&));
};
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // MOCK_WIFI_IFACE_UTIL_H_

39
wifi/1.6/default/tests/mock_wifi_legacy_hal.cpp
View File

@@ -1,39 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
MockWifiLegacyHal::MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary)
: WifiLegacyHal(iface_tool, fn, is_primary) {}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

71
wifi/1.6/default/tests/mock_wifi_legacy_hal.h
View File

@@ -1,71 +0,0 @@
/*
* Copyright (C) 2017 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 MOCK_WIFI_LEGACY_HAL_H_
#define MOCK_WIFI_LEGACY_HAL_H_
#include <gmock/gmock.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
class MockWifiLegacyHal : public WifiLegacyHal {
public:
MockWifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const wifi_hal_fn& fn, bool is_primary);
MOCK_METHOD0(initialize, wifi_error());
MOCK_METHOD0(start, wifi_error());
MOCK_METHOD2(stop,
wifi_error(std::unique_lock<std::recursive_mutex>*, const std::function<void()>&));
MOCK_METHOD2(setDfsFlag, wifi_error(const std::string&, bool));
MOCK_METHOD2(registerRadioModeChangeCallbackHandler,
wifi_error(const std::string&, const on_radio_mode_change_callback&));
MOCK_METHOD1(getFirmwareVersion,
std::pair<wifi_error, std::string>(const std::string& iface_name));
MOCK_METHOD1(getDriverVersion,
std::pair<wifi_error, std::string>(const std::string& iface_name));
MOCK_METHOD2(selectTxPowerScenario,
wifi_error(const std::string& iface_name, wifi_power_scenario scenario));
MOCK_METHOD1(resetTxPowerScenario, wifi_error(const std::string& iface_name));
MOCK_METHOD2(nanRegisterCallbackHandlers,
wifi_error(const std::string&, const NanCallbackHandlers&));
MOCK_METHOD2(nanDisableRequest, wifi_error(const std::string&, transaction_id));
MOCK_METHOD3(nanDataInterfaceDelete,
wifi_error(const std::string&, transaction_id, const std::string&));
MOCK_METHOD2(createVirtualInterface,
wifi_error(const std::string& ifname, wifi_interface_type iftype));
MOCK_METHOD1(deleteVirtualInterface, wifi_error(const std::string& ifname));
MOCK_METHOD0(waitForDriverReady, wifi_error());
MOCK_METHOD2(getSupportedIfaceName, wifi_error(uint32_t, std::string&));
MOCK_METHOD1(registerSubsystemRestartCallbackHandler,
wifi_error(const on_subsystem_restart_callback&));
MOCK_METHOD1(getSupportedFeatureSet, std::pair<wifi_error, uint64_t>(const std::string&));
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // MOCK_WIFI_LEGACY_HAL_H_

37
wifi/1.6/default/tests/mock_wifi_mode_controller.cpp
View File

@@ -1,37 +0,0 @@
/*
* Copyright (C) 2017 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "mock_wifi_mode_controller.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
MockWifiModeController::MockWifiModeController() : WifiModeController() {}
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

46
wifi/1.6/default/tests/mock_wifi_mode_controller.h
View File

@@ -1,46 +0,0 @@
/*
* Copyright (C) 2017 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 MOCK_WIFI_MODE_CONTROLLER_H_
#define MOCK_WIFI_MODE_CONTROLLER_H_
#include <gmock/gmock.h>
#include "wifi_mode_controller.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
class MockWifiModeController : public WifiModeController {
public:
MockWifiModeController();
MOCK_METHOD0(initialize, bool());
MOCK_METHOD1(changeFirmwareMode, bool(IfaceType));
MOCK_METHOD1(isFirmwareModeChangeNeeded, bool(IfaceType));
MOCK_METHOD0(deinitialize, bool());
};
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // MOCK_WIFI_MODE_CONTROLLER_H_

97
wifi/1.6/default/tests/ringbuffer_unit_tests.cpp
View File

@@ -1,97 +0,0 @@
/*
* Copyright (C) 2018, 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.
*/
#include <gmock/gmock.h>
#include "ringbuffer.h"
using testing::Return;
using testing::Test;
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
class RingbufferTest : public Test {
public:
const uint32_t maxBufferSize_ = 10;
Ringbuffer buffer_{maxBufferSize_};
};
TEST_F(RingbufferTest, CreateEmptyBuffer) {
ASSERT_TRUE(buffer_.getData().empty());
}
TEST_F(RingbufferTest, CanUseFullBufferCapacity) {
const std::vector<uint8_t> input(maxBufferSize_ / 2, '0');
const std::vector<uint8_t> input2(maxBufferSize_ / 2, '1');
buffer_.append(input);
buffer_.append(input2);
ASSERT_EQ(2u, buffer_.getData().size());
EXPECT_EQ(input, buffer_.getData().front());
EXPECT_EQ(input2, buffer_.getData().back());
}
TEST_F(RingbufferTest, OldDataIsRemovedOnOverflow) {
const std::vector<uint8_t> input(maxBufferSize_ / 2, '0');
const std::vector<uint8_t> input2(maxBufferSize_ / 2, '1');
const std::vector<uint8_t> input3 = {'G'};
buffer_.append(input);
buffer_.append(input2);
buffer_.append(input3);
ASSERT_EQ(2u, buffer_.getData().size());
EXPECT_EQ(input2, buffer_.getData().front());
EXPECT_EQ(input3, buffer_.getData().back());
}
TEST_F(RingbufferTest, MultipleOldDataIsRemovedOnOverflow) {
const std::vector<uint8_t> input(maxBufferSize_ / 2, '0');
const std::vector<uint8_t> input2(maxBufferSize_ / 2, '1');
const std::vector<uint8_t> input3(maxBufferSize_, '2');
buffer_.append(input);
buffer_.append(input2);
buffer_.append(input3);
ASSERT_EQ(1u, buffer_.getData().size());
EXPECT_EQ(input3, buffer_.getData().front());
}
TEST_F(RingbufferTest, AppendingEmptyBufferDoesNotAddGarbage) {
const std::vector<uint8_t> input = {};
buffer_.append(input);
ASSERT_TRUE(buffer_.getData().empty());
}
TEST_F(RingbufferTest, OversizedAppendIsDropped) {
const std::vector<uint8_t> input(maxBufferSize_ + 1, '0');
buffer_.append(input);
ASSERT_TRUE(buffer_.getData().empty());
}
TEST_F(RingbufferTest, OversizedAppendDoesNotDropExistingData) {
const std::vector<uint8_t> input(maxBufferSize_, '0');
const std::vector<uint8_t> input2(maxBufferSize_ + 1, '1');
buffer_.append(input);
buffer_.append(input2);
ASSERT_EQ(1u, buffer_.getData().size());
EXPECT_EQ(input, buffer_.getData().front());
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

26
wifi/1.6/default/tests/runtests.sh
View File

@@ -1,26 +0,0 @@
#!/usr/bin/env bash
# Copyright(C) 2017 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.
if [ -z $ANDROID_BUILD_TOP ]; then
echo "You need to source and lunch before you can use this script"
exit 1
fi
set -e
$ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode android.hardware.wifi@1.0-service-tests
adb root
adb sync data
adb shell /data/nativetest64/vendor/android.hardware.wifi@1.0-service-tests/android.hardware.wifi@1.0-service-tests

864
wifi/1.6/default/tests/wifi_chip_unit_tests.cpp
View File

@@ -1,864 +0,0 @@
/*
* Copyright (C) 2017, 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <cutils/properties.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "wifi_chip.h"
#include "mock_interface_tool.h"
#include "mock_wifi_feature_flags.h"
#include "mock_wifi_iface_util.h"
#include "mock_wifi_legacy_hal.h"
#include "mock_wifi_mode_controller.h"
using testing::NiceMock;
using testing::Return;
using testing::Test;
namespace {
using android::hardware::wifi::V1_0::ChipId;
constexpr ChipId kFakeChipId = 5;
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
class WifiChipTest : public Test {
protected:
void setupV1IfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
{{{{IfaceConcurrencyType::STA}, 1}, {{IfaceConcurrencyType::P2P}, 1}}}
};
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsAp = {
{{{{IfaceConcurrencyType::AP}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
{feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV1_AwareIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
};
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsAp = {
{{{{IfaceConcurrencyType::AP}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta},
{feature_flags::chip_mode_ids::kV1Ap, combinationsAp}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV1_AwareDisabledApIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinationsSta = {
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV1Sta, combinationsSta}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV2_AwareIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
{{{{IfaceConcurrencyType::STA}, 1}, {{IfaceConcurrencyType::AP}, 1}}},
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setupV2_AwareDisabledApIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
{{{{IfaceConcurrencyType::STA}, 1},
{{IfaceConcurrencyType::P2P, IfaceConcurrencyType::NAN}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void setup_MultiIfaceCombination() {
// clang-format off
const hidl_vec<IWifiChip::ChipConcurrencyCombination> combinations = {
{{{{IfaceConcurrencyType::STA}, 3}, {{IfaceConcurrencyType::AP}, 1}}}
};
const std::vector<V1_6::IWifiChip::ChipMode> modes = {
{feature_flags::chip_mode_ids::kV3, combinations}
};
// clang-format on
EXPECT_CALL(*feature_flags_, getChipModes(true)).WillRepeatedly(testing::Return(modes));
}
void assertNumberOfModes(uint32_t num_modes) {
chip_->getAvailableModes_1_6([num_modes](const WifiStatus& status,
const std::vector<WifiChip::ChipMode>& modes) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
// V2_Aware has 1 mode of operation.
ASSERT_EQ(num_modes, modes.size());
});
}
void findModeAndConfigureForIfaceType(const IfaceConcurrencyType& type) {
// This should be aligned with kInvalidModeId in wifi_chip.cpp.
ChipModeId mode_id = UINT32_MAX;
chip_->getAvailableModes_1_6([&mode_id, &type](
const WifiStatus& status,
const std::vector<WifiChip::ChipMode>& modes) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
for (const auto& mode : modes) {
for (const auto& combination : mode.availableCombinations) {
for (const auto& limit : combination.limits) {
if (limit.types.end() !=
std::find(limit.types.begin(), limit.types.end(), type)) {
mode_id = mode.id;
}
}
}
}
});
ASSERT_NE(UINT32_MAX, mode_id);
chip_->configureChip(mode_id, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
}
// Returns an empty string on error.
std::string createIface(const IfaceType& type) {
std::string iface_name;
if (type == IfaceType::AP) {
chip_->createApIface(
[&iface_name](const WifiStatus& status, const sp<V1_0::IWifiApIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
} else if (type == IfaceType::NAN) {
chip_->createNanIface(
[&iface_name](const WifiStatus& status,
const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
} else if (type == IfaceType::P2P) {
chip_->createP2pIface(
[&iface_name](const WifiStatus& status, const sp<IWifiP2pIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
} else if (type == IfaceType::STA) {
chip_->createStaIface(
[&iface_name](const WifiStatus& status, const sp<V1_0::IWifiStaIface>& iface) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(iface.get(), nullptr);
iface->getName([&iface_name](const WifiStatus& status,
const hidl_string& name) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
iface_name = name.c_str();
});
}
});
}
return iface_name;
}
void removeIface(const IfaceType& type, const std::string& iface_name) {
if (type == IfaceType::AP) {
chip_->removeApIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
} else if (type == IfaceType::NAN) {
chip_->removeNanIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
} else if (type == IfaceType::P2P) {
chip_->removeP2pIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
} else if (type == IfaceType::STA) {
chip_->removeStaIface(iface_name, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
}
}
bool createRttController() {
bool success = false;
chip_->createRttController_1_6(
NULL, [&success](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
success = true;
}
});
return success;
}
static void subsystemRestartHandler(const std::string& /*error*/) {}
sp<WifiChip> chip_;
ChipId chip_id_ = kFakeChipId;
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
std::shared_ptr<NiceMock<mode_controller::MockWifiModeController>> mode_controller_{
new NiceMock<mode_controller::MockWifiModeController>};
std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
std::shared_ptr<NiceMock<feature_flags::MockWifiFeatureFlags>> feature_flags_{
new NiceMock<feature_flags::MockWifiFeatureFlags>};
public:
void SetUp() override {
chip_ = new WifiChip(chip_id_, true, legacy_hal_, mode_controller_, iface_util_,
feature_flags_, subsystemRestartHandler);
EXPECT_CALL(*mode_controller_, changeFirmwareMode(testing::_))
.WillRepeatedly(testing::Return(true));
EXPECT_CALL(*legacy_hal_, start())
.WillRepeatedly(testing::Return(legacy_hal::WIFI_SUCCESS));
// Vendor HAL does not override the name by default.
EXPECT_CALL(*legacy_hal_, getSupportedIfaceName(testing::_, testing::_))
.WillRepeatedly(testing::Return(legacy_hal::WIFI_ERROR_UNKNOWN));
}
void TearDown() override {
// Restore default system iface names (This should ideally be using a
// mock).
property_set("wifi.interface", "wlan0");
property_set("wifi.concurrent.interface", "wlan1");
property_set("wifi.aware.interface", nullptr);
}
};
////////// V1 Iface Combinations ////////////
// Mode 1 - STA + P2P
// Mode 2 - AP
class WifiChipV1IfaceCombinationTest : public WifiChipTest {
public:
void SetUp() override {
setupV1IfaceCombination();
WifiChipTest::SetUp();
// V1 has 2 modes of operation.
assertNumberOfModes(2u);
}
};
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
}
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createIface(IfaceType::AP).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
}
TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChipV1IfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
////////// V1 + Aware Iface Combinations ////////////
// Mode 1 - STA + P2P/NAN
// Mode 2 - AP
class WifiChipV1_AwareIfaceCombinationTest : public WifiChipTest {
public:
void SetUp() override {
setupV1_AwareIfaceCombination();
WifiChipTest::SetUp();
// V1_Aware has 2 modes of operation.
assertNumberOfModes(2u);
}
};
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateAp_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createIface(IfaceType::AP).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2PNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
ASSERT_FALSE(p2p_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
// After removing P2P iface, NAN iface creation should succeed.
removeIface(IfaceType::P2P, p2p_iface_name);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
ASSERT_FALSE(nan_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
// After removing NAN iface, P2P iface creation should succeed.
removeIface(IfaceType::NAN, nan_iface_name);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateAp_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateSta_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateP2p_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, ApMode_CreateNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createRttController());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createRttController());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, RttControllerFlowApToSta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
const auto ap_iface_name = createIface(IfaceType::AP);
ASSERT_FALSE(ap_iface_name.empty());
ASSERT_FALSE(createRttController());
removeIface(IfaceType::AP, ap_iface_name);
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createRttController());
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
TEST_F(WifiChipV1_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
////////// V2 + Aware Iface Combinations ////////////
// Mode 1 - STA + STA/AP
// - STA + P2P/NAN
class WifiChipV2_AwareIfaceCombinationTest : public WifiChipTest {
public:
void SetUp() override {
setupV2_AwareIfaceCombination();
WifiChipTest::SetUp();
// V2_Aware has 1 mode of operation.
assertNumberOfModes(1u);
}
};
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateAp_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaSta_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
ASSERT_TRUE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateSta_AfterStaApRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
const auto sta_iface_name = createIface(IfaceType::STA);
ASSERT_FALSE(sta_iface_name.empty());
const auto ap_iface_name = createIface(IfaceType::AP);
ASSERT_FALSE(ap_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::STA).empty());
// After removing AP & STA iface, STA iface creation should succeed.
removeIface(IfaceType::STA, sta_iface_name);
removeIface(IfaceType::AP, ap_iface_name);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2PNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
ASSERT_FALSE(p2p_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
// After removing P2P iface, NAN iface creation should succeed.
removeIface(IfaceType::P2P, p2p_iface_name);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
ASSERT_FALSE(nan_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
// After removing NAN iface, P2P iface creation should succeed.
removeIface(IfaceType::NAN, nan_iface_name);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApNan_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_FALSE(createIface(IfaceType::AP).empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateApP2p_ShouldFail) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_FALSE(createIface(IfaceType::AP).empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaNan_AfterP2pRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto p2p_iface_name = createIface(IfaceType::P2P);
ASSERT_FALSE(p2p_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::NAN).empty());
// After removing P2P iface, NAN iface creation should succeed.
removeIface(IfaceType::P2P, p2p_iface_name);
ASSERT_FALSE(createIface(IfaceType::NAN).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, StaMode_CreateStaP2p_AfterNanRemove_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
const auto nan_iface_name = createIface(IfaceType::NAN);
ASSERT_FALSE(nan_iface_name.empty());
ASSERT_TRUE(createIface(IfaceType::P2P).empty());
// After removing NAN iface, P2P iface creation should succeed.
removeIface(IfaceType::NAN, nan_iface_name);
ASSERT_FALSE(createIface(IfaceType::P2P).empty());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateStaAp_EnsureDifferentIfaceNames) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
const auto sta_iface_name = createIface(IfaceType::STA);
const auto ap_iface_name = createIface(IfaceType::AP);
ASSERT_FALSE(sta_iface_name.empty());
ASSERT_FALSE(ap_iface_name.empty());
ASSERT_NE(sta_iface_name, ap_iface_name);
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlowStaModeNoSta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_TRUE(createRttController());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlowStaModeWithSta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createRttController());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, RttControllerFlow) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::AP).empty());
ASSERT_TRUE(createRttController());
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlySta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan0", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, SelectTxScenarioWithOnlyAp) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::AP);
ASSERT_EQ(createIface(IfaceType::AP), "wlan1");
EXPECT_CALL(*legacy_hal_, selectTxPowerScenario("wlan1", testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
chip_->selectTxPowerScenario_1_2(
V1_2::IWifiChip::TxPowerScenario::ON_HEAD_CELL_OFF,
[](const WifiStatus& status) { ASSERT_EQ(WifiStatusCode::SUCCESS, status.code); });
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveNanOnStaRemove) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
// Create NAN iface
ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
// We should have 1 nan iface.
chip_->getNanIfaceNames([](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
ASSERT_EQ(iface_names.size(), 1u);
ASSERT_EQ(iface_names[0], "wlan0");
});
// Retrieve the exact iface object.
sp<android::hardware::wifi::V1_0::IWifiNanIface> nan_iface;
chip_->getNanIface("wlan0",
[&nan_iface](const WifiStatus& status,
const sp<android::hardware::wifi::V1_0::IWifiNanIface>& iface) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
ASSERT_NE(iface.get(), nullptr);
nan_iface = iface;
});
// Remove the STA iface.
removeIface(IfaceType::STA, "wlan0");
// We should have 0 nan iface now.
chip_->getNanIfaceNames([](const WifiStatus& status, const hidl_vec<hidl_string>& iface_names) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
ASSERT_EQ(iface_names.size(), 0u);
});
// Any operation on the nan iface object should return error now.
nan_iface->getName([](const WifiStatus& status, const std::string& /* iface_name */) {
ASSERT_EQ(WifiStatusCode::ERROR_WIFI_IFACE_INVALID, status.code);
});
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, InvalidateAndRemoveRttControllerOnStaRemove) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
// Create RTT controller
sp<IWifiRttController> rtt_controller;
chip_->createRttController_1_6(
NULL, [&rtt_controller](const WifiStatus& status, const sp<IWifiRttController>& rtt) {
if (WifiStatusCode::SUCCESS == status.code) {
ASSERT_NE(rtt.get(), nullptr);
rtt_controller = rtt;
}
});
// Remove the STA iface.
removeIface(IfaceType::STA, "wlan0");
// Any operation on the rtt controller object should return error now.
rtt_controller->getBoundIface([](const WifiStatus& status, const sp<IWifiIface>& /* iface */) {
ASSERT_EQ(WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, status.code);
});
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithSharedNanIface) {
property_set("wifi.aware.interface", nullptr);
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
ASSERT_EQ(createIface(IfaceType::NAN), "wlan0");
removeIface(IfaceType::NAN, "wlan0");
EXPECT_CALL(*iface_util_, setUpState(testing::_, testing::_)).Times(0);
}
TEST_F(WifiChipV2_AwareIfaceCombinationTest, CreateNanWithDedicatedNanIface) {
property_set("wifi.aware.interface", "aware0");
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
EXPECT_CALL(*iface_util_, ifNameToIndex("aware0")).WillOnce(testing::Return(4));
EXPECT_CALL(*iface_util_, setUpState("aware0", true)).WillOnce(testing::Return(true));
ASSERT_EQ(createIface(IfaceType::NAN), "aware0");
EXPECT_CALL(*iface_util_, setUpState("aware0", false)).WillOnce(testing::Return(true));
removeIface(IfaceType::NAN, "aware0");
}
////////// V1 Iface Combinations when AP creation is disabled //////////
class WifiChipV1_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
public:
void SetUp() override {
setupV1_AwareDisabledApIfaceCombination();
WifiChipTest::SetUp();
}
};
TEST_F(WifiChipV1_AwareDisabledApIfaceCombinationTest, StaMode_CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createIface(IfaceType::AP).empty());
}
////////// V2 Iface Combinations when AP creation is disabled //////////
class WifiChipV2_AwareDisabledApIfaceCombinationTest : public WifiChipTest {
public:
void SetUp() override {
setupV2_AwareDisabledApIfaceCombination();
WifiChipTest::SetUp();
}
};
TEST_F(WifiChipV2_AwareDisabledApIfaceCombinationTest, CreateSta_ShouldSucceed) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createIface(IfaceType::AP).empty());
}
////////// Hypothetical Iface Combination with multiple ifaces //////////
class WifiChip_MultiIfaceTest : public WifiChipTest {
public:
void SetUp() override {
setup_MultiIfaceCombination();
WifiChipTest::SetUp();
}
};
TEST_F(WifiChip_MultiIfaceTest, Create3Sta) {
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_FALSE(createIface(IfaceType::STA).empty());
ASSERT_TRUE(createIface(IfaceType::STA).empty());
}
TEST_F(WifiChip_MultiIfaceTest, CreateStaWithDefaultNames) {
property_set("wifi.interface.0", "");
property_set("wifi.interface.1", "");
property_set("wifi.interface.2", "");
property_set("wifi.interface", "");
property_set("wifi.concurrent.interface", "");
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
ASSERT_EQ(createIface(IfaceType::STA), "wlan1");
ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
}
TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomNames) {
property_set("wifi.interface.0", "test0");
property_set("wifi.interface.1", "test1");
property_set("wifi.interface.2", "test2");
property_set("wifi.interface", "bad0");
property_set("wifi.concurrent.interface", "bad1");
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "bad0");
ASSERT_EQ(createIface(IfaceType::STA), "bad1");
ASSERT_EQ(createIface(IfaceType::STA), "test2");
}
TEST_F(WifiChip_MultiIfaceTest, CreateStaWithCustomAltNames) {
property_set("wifi.interface.0", "");
property_set("wifi.interface.1", "");
property_set("wifi.interface.2", "");
property_set("wifi.interface", "testA0");
property_set("wifi.concurrent.interface", "testA1");
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
ASSERT_EQ(createIface(IfaceType::STA), "testA0");
ASSERT_EQ(createIface(IfaceType::STA), "testA1");
ASSERT_EQ(createIface(IfaceType::STA), "wlan2");
}
TEST_F(WifiChip_MultiIfaceTest, CreateApStartsWithIdx1) {
// WifiChip_MultiIfaceTest iface combo: STAx3 + APx1
// When the HAL support dual STAs, AP should start with idx 2.
findModeAndConfigureForIfaceType(IfaceConcurrencyType::STA);
// First AP will be slotted to wlan1.
ASSERT_EQ(createIface(IfaceType::AP), "wlan2");
// First STA will be slotted to wlan0.
ASSERT_EQ(createIface(IfaceType::STA), "wlan0");
// All further STA will be slotted to the remaining free indices.
ASSERT_EQ(createIface(IfaceType::STA), "wlan1");
ASSERT_EQ(createIface(IfaceType::STA), "wlan3");
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

96
wifi/1.6/default/tests/wifi_iface_util_unit_tests.cpp
View File

@@ -1,96 +0,0 @@
/*
* Copyright (C) 2019, 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <gmock/gmock.h>
#undef NAN
#include "wifi_iface_util.h"
#include "mock_interface_tool.h"
#include "mock_wifi_legacy_hal.h"
using testing::NiceMock;
using testing::Test;
namespace {
constexpr uint8_t kValidUnicastLocallyAssignedMacAddressMask = 0x02;
constexpr uint8_t kMacAddress[] = {0x02, 0x12, 0x45, 0x56, 0xab, 0xcc};
constexpr char kIfaceName[] = "test-wlan0";
bool isValidUnicastLocallyAssignedMacAddress(const std::array<uint8_t, 6>& mac_address) {
uint8_t first_byte = mac_address[0];
return (first_byte & 0x3) == kValidUnicastLocallyAssignedMacAddressMask;
}
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
class WifiIfaceUtilTest : public Test {
protected:
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
WifiIfaceUtil* iface_util_ = new WifiIfaceUtil(iface_tool_, legacy_hal_);
};
TEST_F(WifiIfaceUtilTest, GetOrCreateRandomMacAddress) {
auto mac_address = iface_util_->getOrCreateRandomMacAddress();
ASSERT_TRUE(isValidUnicastLocallyAssignedMacAddress(mac_address));
// All further calls should return the same MAC address.
ASSERT_EQ(mac_address, iface_util_->getOrCreateRandomMacAddress());
ASSERT_EQ(mac_address, iface_util_->getOrCreateRandomMacAddress());
}
TEST_F(WifiIfaceUtilTest, IfaceEventHandlers_SetMacAddress) {
std::array<uint8_t, 6> mac_address = {};
std::copy(std::begin(kMacAddress), std::end(kMacAddress), std::begin(mac_address));
EXPECT_CALL(*iface_tool_, SetMacAddress(testing::_, testing::_))
.WillRepeatedly(testing::Return(true));
EXPECT_CALL(*iface_tool_, SetUpState(testing::_, testing::_))
.WillRepeatedly(testing::Return(true));
// Register for iface state toggle events.
bool callback_invoked = false;
iface_util::IfaceEventHandlers event_handlers = {};
event_handlers.on_state_toggle_off_on =
[&callback_invoked](const std::string& /* iface_name */) { callback_invoked = true; };
iface_util_->registerIfaceEventHandlers(kIfaceName, event_handlers);
// Invoke setMacAddress and ensure that the cb is invoked.
ASSERT_TRUE(iface_util_->setMacAddress(kIfaceName, mac_address));
ASSERT_TRUE(callback_invoked);
// Unregister for iface state toggle events.
callback_invoked = false;
iface_util_->unregisterIfaceEventHandlers(kIfaceName);
// Invoke setMacAddress and ensure that the cb is not invoked.
ASSERT_TRUE(iface_util_->setMacAddress(kIfaceName, mac_address));
ASSERT_FALSE(callback_invoked);
}
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

138
wifi/1.6/default/tests/wifi_nan_iface_unit_tests.cpp
View File

@@ -1,138 +0,0 @@
/*
* Copyright (C) 2019, 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <cutils/properties.h>
#include <gmock/gmock.h>
#undef NAN // This is weird, NAN is defined in bionic/libc/include/math.h:38
#include "wifi_nan_iface.h"
#include "mock_interface_tool.h"
#include "mock_wifi_feature_flags.h"
#include "mock_wifi_iface_util.h"
#include "mock_wifi_legacy_hal.h"
using testing::NiceMock;
using testing::Return;
using testing::Test;
namespace {
constexpr char kIfaceName[] = "mockWlan0";
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using android::hardware::wifi::V1_2::NanDataPathConfirmInd;
bool CaptureIfaceEventHandlers(const std::string& /* iface_name*/,
iface_util::IfaceEventHandlers in_iface_event_handlers,
iface_util::IfaceEventHandlers* out_iface_event_handlers) {
*out_iface_event_handlers = in_iface_event_handlers;
return true;
}
class MockNanIfaceEventCallback : public V1_5::IWifiNanIfaceEventCallback {
public:
MockNanIfaceEventCallback() = default;
MOCK_METHOD3(notifyCapabilitiesResponse,
Return<void>(uint16_t, const WifiNanStatus&,
const android::hardware::wifi::V1_0::NanCapabilities&));
MOCK_METHOD2(notifyEnableResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyConfigResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyDisableResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD3(notifyStartPublishResponse, Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
MOCK_METHOD2(notifyStopPublishResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD3(notifyStartSubscribeResponse,
Return<void>(uint16_t, const WifiNanStatus&, uint8_t));
MOCK_METHOD2(notifyStopSubscribeResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyTransmitFollowupResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyCreateDataInterfaceResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyDeleteDataInterfaceResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD3(notifyInitiateDataPathResponse,
Return<void>(uint16_t, const WifiNanStatus&, uint32_t));
MOCK_METHOD2(notifyRespondToDataPathIndicationResponse,
Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD2(notifyTerminateDataPathResponse, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD1(eventClusterEvent, Return<void>(const NanClusterEventInd&));
MOCK_METHOD1(eventDisabled, Return<void>(const WifiNanStatus&));
MOCK_METHOD2(eventPublishTerminated, Return<void>(uint8_t, const WifiNanStatus&));
MOCK_METHOD2(eventSubscribeTerminated, Return<void>(uint8_t, const WifiNanStatus&));
MOCK_METHOD1(eventMatch, Return<void>(const V1_0::NanMatchInd&));
MOCK_METHOD1(eventMatch_1_6, Return<void>(const NanMatchInd&));
MOCK_METHOD2(eventMatchExpired, Return<void>(uint8_t, uint32_t));
MOCK_METHOD1(eventFollowupReceived, Return<void>(const NanFollowupReceivedInd&));
MOCK_METHOD2(eventTransmitFollowup, Return<void>(uint16_t, const WifiNanStatus&));
MOCK_METHOD1(eventDataPathRequest, Return<void>(const NanDataPathRequestInd&));
MOCK_METHOD1(eventDataPathConfirm,
Return<void>(const android::hardware::wifi::V1_0::NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathTerminated, Return<void>(uint32_t));
MOCK_METHOD1(eventDataPathConfirm_1_2,
Return<void>(const android::hardware::wifi::V1_2::NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathConfirm_1_6, Return<void>(const NanDataPathConfirmInd&));
MOCK_METHOD1(eventDataPathScheduleUpdate,
Return<void>(const android::hardware::wifi::V1_2::NanDataPathScheduleUpdateInd&));
MOCK_METHOD1(eventDataPathScheduleUpdate_1_6,
Return<void>(const NanDataPathScheduleUpdateInd&));
MOCK_METHOD3(notifyCapabilitiesResponse_1_5,
Return<void>(uint16_t, const WifiNanStatus&, const V1_5::NanCapabilities&));
};
class WifiNanIfaceTest : public Test {
protected:
legacy_hal::wifi_hal_fn fake_func_table_;
std::shared_ptr<NiceMock<wifi_system::MockInterfaceTool>> iface_tool_{
new NiceMock<wifi_system::MockInterfaceTool>};
std::shared_ptr<NiceMock<legacy_hal::MockWifiLegacyHal>> legacy_hal_{
new NiceMock<legacy_hal::MockWifiLegacyHal>(iface_tool_, fake_func_table_, true)};
std::shared_ptr<NiceMock<iface_util::MockWifiIfaceUtil>> iface_util_{
new NiceMock<iface_util::MockWifiIfaceUtil>(iface_tool_, legacy_hal_)};
};
TEST_F(WifiNanIfaceTest, IfacEventHandlers_OnStateToggleOffOn) {
iface_util::IfaceEventHandlers captured_iface_event_handlers = {};
EXPECT_CALL(*legacy_hal_, nanRegisterCallbackHandlers(testing::_, testing::_))
.WillOnce(testing::Return(legacy_hal::WIFI_SUCCESS));
EXPECT_CALL(*iface_util_, registerIfaceEventHandlers(testing::_, testing::_))
.WillOnce(testing::Invoke(bind(CaptureIfaceEventHandlers, std::placeholders::_1,
std::placeholders::_2, &captured_iface_event_handlers)));
sp<WifiNanIface> nan_iface = new WifiNanIface(kIfaceName, false, legacy_hal_, iface_util_);
// Register a mock nan event callback.
sp<NiceMock<MockNanIfaceEventCallback>> mock_event_callback{
new NiceMock<MockNanIfaceEventCallback>};
nan_iface->registerEventCallback(mock_event_callback, [](const WifiStatus& status) {
ASSERT_EQ(WifiStatusCode::SUCCESS, status.code);
});
// Ensure that the eventDisabled() function in mock callback will be
// invoked.
WifiNanStatus expected_nan_status = {NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED, ""};
EXPECT_CALL(*mock_event_callback, eventDisabled(expected_nan_status)).Times(1);
// Trigger the iface state toggle callback.
captured_iface_event_handlers.on_state_toggle_off_on(kIfaceName);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

294
wifi/1.6/default/wifi.cpp
View File

@@ -1,294 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "wifi.h"
#include "wifi_status_util.h"
namespace {
// Starting Chip ID, will be assigned to primary chip
static constexpr android::hardware::wifi::V1_0::ChipId kPrimaryChipId = 0;
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
using hidl_return_util::validateAndCallWithLock;
Wifi::Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags)
: iface_tool_(iface_tool),
legacy_hal_factory_(legacy_hal_factory),
mode_controller_(mode_controller),
feature_flags_(feature_flags),
run_state_(RunState::STOPPED) {}
bool Wifi::isValid() {
// This object is always valid.
return true;
}
Return<void> Wifi::registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::registerEventCallbackInternal, hidl_status_cb, event_callback);
}
Return<void> Wifi::registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback>& event_callback,
registerEventCallback_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN,
&Wifi::registerEventCallbackInternal_1_5, hidl_status_cb,
event_callback);
}
Return<bool> Wifi::isStarted() {
return run_state_ != RunState::STOPPED;
}
Return<void> Wifi::start(start_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::startInternal,
hidl_status_cb);
}
Return<void> Wifi::stop(stop_cb hidl_status_cb) {
return validateAndCallWithLock(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::stopInternal,
hidl_status_cb);
}
Return<void> Wifi::getChipIds(getChipIds_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipIdsInternal,
hidl_status_cb);
}
Return<void> Wifi::getChip(ChipId chip_id, getChip_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_UNKNOWN, &Wifi::getChipInternal,
hidl_status_cb, chip_id);
}
Return<void> Wifi::debug(const hidl_handle& handle, const hidl_vec<hidl_string>&) {
LOG(INFO) << "-----------Debug is called----------------";
if (chips_.size() == 0) {
return Void();
}
for (sp<WifiChip> chip : chips_) {
if (!chip.get()) continue;
chip->debug(handle, {});
}
return Void();
}
WifiStatus Wifi::registerEventCallbackInternal(
const sp<V1_0::IWifiEventCallback>& event_callback __unused) {
// Deprecated support for this callback.
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus Wifi::registerEventCallbackInternal_1_5(
const sp<V1_5::IWifiEventCallback>& event_callback) {
if (!event_cb_handler_.addCallback(event_callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus Wifi::startInternal() {
if (run_state_ == RunState::STARTED) {
return createWifiStatus(WifiStatusCode::SUCCESS);
} else if (run_state_ == RunState::STOPPING) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
}
WifiStatus wifi_status = initializeModeControllerAndLegacyHal();
if (wifi_status.code == WifiStatusCode::SUCCESS) {
// Register the callback for subsystem restart
const auto& on_subsystem_restart_callback = [this](const std::string& error) {
WifiStatus wifi_status = createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, error);
for (const auto& callback : event_cb_handler_.getCallbacks()) {
LOG(INFO) << "Attempting to invoke onSubsystemRestart "
"callback";
if (!callback->onSubsystemRestart(wifi_status).isOk()) {
LOG(ERROR) << "Failed to invoke onSubsystemRestart callback";
} else {
LOG(INFO) << "Succeeded to invoke onSubsystemRestart "
"callback";
}
}
};
// Create the chip instance once the HAL is started.
android::hardware::wifi::V1_0::ChipId chipId = kPrimaryChipId;
for (auto& hal : legacy_hals_) {
chips_.push_back(
new WifiChip(chipId, chipId == kPrimaryChipId, hal, mode_controller_,
std::make_shared<iface_util::WifiIfaceUtil>(iface_tool_, hal),
feature_flags_, on_subsystem_restart_callback));
chipId++;
}
run_state_ = RunState::STARTED;
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onStart().isOk()) {
LOG(ERROR) << "Failed to invoke onStart callback";
};
}
LOG(INFO) << "Wifi HAL started";
} else {
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onFailure(wifi_status).isOk()) {
LOG(ERROR) << "Failed to invoke onFailure callback";
}
}
LOG(ERROR) << "Wifi HAL start failed";
// Clear the event callback objects since the HAL start failed.
event_cb_handler_.invalidate();
}
return wifi_status;
}
WifiStatus Wifi::stopInternal(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
if (run_state_ == RunState::STOPPED) {
return createWifiStatus(WifiStatusCode::SUCCESS);
} else if (run_state_ == RunState::STOPPING) {
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, "HAL is stopping");
}
// Clear the chip object and its child objects since the HAL is now
// stopped.
for (auto& chip : chips_) {
if (chip.get()) {
chip->invalidate();
chip.clear();
}
}
chips_.clear();
WifiStatus wifi_status = stopLegacyHalAndDeinitializeModeController(lock);
if (wifi_status.code == WifiStatusCode::SUCCESS) {
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onStop().isOk()) {
LOG(ERROR) << "Failed to invoke onStop callback";
};
}
LOG(INFO) << "Wifi HAL stopped";
} else {
for (const auto& callback : event_cb_handler_.getCallbacks()) {
if (!callback->onFailure(wifi_status).isOk()) {
LOG(ERROR) << "Failed to invoke onFailure callback";
}
}
LOG(ERROR) << "Wifi HAL stop failed";
}
// Clear the event callback objects since the HAL is now stopped.
event_cb_handler_.invalidate();
return wifi_status;
}
std::pair<WifiStatus, std::vector<ChipId>> Wifi::getChipIdsInternal() {
std::vector<ChipId> chip_ids;
for (auto& chip : chips_) {
ChipId chip_id = getChipIdFromWifiChip(chip);
if (chip_id != UINT32_MAX) chip_ids.emplace_back(chip_id);
}
return {createWifiStatus(WifiStatusCode::SUCCESS), std::move(chip_ids)};
}
std::pair<WifiStatus, sp<V1_4::IWifiChip>> Wifi::getChipInternal(ChipId chip_id) {
for (auto& chip : chips_) {
ChipId cand_id = getChipIdFromWifiChip(chip);
if ((cand_id != UINT32_MAX) && (cand_id == chip_id))
return {createWifiStatus(WifiStatusCode::SUCCESS), chip};
}
return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
}
WifiStatus Wifi::initializeModeControllerAndLegacyHal() {
if (!mode_controller_->initialize()) {
LOG(ERROR) << "Failed to initialize firmware mode controller";
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
legacy_hals_ = legacy_hal_factory_->getHals();
if (legacy_hals_.empty()) return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
int index = 0; // for failure log
for (auto& hal : legacy_hals_) {
legacy_hal::wifi_error legacy_status = hal->initialize();
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
// Currently WifiLegacyHal::initialize does not allocate extra mem,
// only initializes the function table. If this changes, need to
// implement WifiLegacyHal::deinitialize and deinitalize the
// HALs already initialized
LOG(ERROR) << "Failed to initialize legacy HAL index: " << index
<< " error: " << legacyErrorToString(legacy_status);
return createWifiStatusFromLegacyError(legacy_status);
}
index++;
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus Wifi::stopLegacyHalAndDeinitializeModeController(
/* NONNULL */ std::unique_lock<std::recursive_mutex>* lock) {
legacy_hal::wifi_error legacy_status = legacy_hal::WIFI_SUCCESS;
int index = 0;
run_state_ = RunState::STOPPING;
for (auto& hal : legacy_hals_) {
legacy_hal::wifi_error tmp = hal->stop(lock, [&]() {});
if (tmp != legacy_hal::WIFI_SUCCESS) {
LOG(ERROR) << "Failed to stop legacy HAL index: " << index
<< " error: " << legacyErrorToString(legacy_status);
legacy_status = tmp;
}
index++;
}
run_state_ = RunState::STOPPED;
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
LOG(ERROR) << "One or more legacy HALs failed to stop";
return createWifiStatusFromLegacyError(legacy_status);
}
if (!mode_controller_->deinitialize()) {
LOG(ERROR) << "Failed to deinitialize firmware mode controller";
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
ChipId Wifi::getChipIdFromWifiChip(sp<WifiChip>& chip) {
ChipId chip_id = UINT32_MAX;
if (chip.get()) {
chip->getId([&](WifiStatus status, uint32_t id) {
if (status.code == WifiStatusCode::SUCCESS) {
chip_id = id;
}
});
}
return chip_id;
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

105
wifi/1.6/default/wifi.h
View File

@@ -1,105 +0,0 @@
/*
* 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_H_
#define WIFI_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 <android/hardware/wifi/1.6/IWifi.h>
#include <android-base/macros.h>
#include <utils/Looper.h>
#include <functional>
#include "hidl_callback_util.h"
#include "wifi_chip.h"
#include "wifi_feature_flags.h"
#include "wifi_legacy_hal.h"
#include "wifi_legacy_hal_factory.h"
#include "wifi_mode_controller.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
/**
* Root HIDL interface object used to control the Wifi HAL.
*/
class Wifi : public V1_6::IWifi {
public:
Wifi(const std::shared_ptr<wifi_system::InterfaceTool> iface_tool,
const std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory,
const std::shared_ptr<mode_controller::WifiModeController> mode_controller,
const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags);
bool isValid();
// HIDL methods exposed.
Return<void> registerEventCallback(const sp<V1_0::IWifiEventCallback>& event_callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_5(const sp<V1_5::IWifiEventCallback>& event_callback,
registerEventCallback_1_5_cb hidl_status_cb) override;
Return<bool> isStarted() override;
Return<void> start(start_cb hidl_status_cb) override;
Return<void> stop(stop_cb hidl_status_cb) override;
Return<void> getChipIds(getChipIds_cb hidl_status_cb) override;
Return<void> getChip(ChipId chip_id, getChip_cb hidl_status_cb) override;
Return<void> debug(const hidl_handle& handle, const hidl_vec<hidl_string>& options) override;
private:
enum class RunState { STOPPED, STARTED, STOPPING };
// Corresponding worker functions for the HIDL methods.
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiEventCallback>& event_callback __unused);
WifiStatus registerEventCallbackInternal_1_5(
const sp<V1_5::IWifiEventCallback>& event_callback);
WifiStatus startInternal();
WifiStatus stopInternal(std::unique_lock<std::recursive_mutex>* lock);
std::pair<WifiStatus, std::vector<ChipId>> getChipIdsInternal();
std::pair<WifiStatus, sp<V1_4::IWifiChip>> getChipInternal(ChipId chip_id);
WifiStatus initializeModeControllerAndLegacyHal();
WifiStatus stopLegacyHalAndDeinitializeModeController(
std::unique_lock<std::recursive_mutex>* lock);
ChipId getChipIdFromWifiChip(sp<WifiChip>& chip);
// Instance is created in this root level |IWifi| HIDL interface object
// and shared with all the child HIDL interface objects.
std::shared_ptr<wifi_system::InterfaceTool> iface_tool_;
std::shared_ptr<legacy_hal::WifiLegacyHalFactory> legacy_hal_factory_;
std::shared_ptr<mode_controller::WifiModeController> mode_controller_;
std::vector<std::shared_ptr<legacy_hal::WifiLegacyHal>> legacy_hals_;
std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags_;
RunState run_state_;
std::vector<sp<WifiChip>> chips_;
hidl_callback_util::HidlCallbackHandler<V1_5::IWifiEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(Wifi);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_H_

204
wifi/1.6/default/wifi_ap_iface.cpp
View File

@@ -1,204 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "hidl_struct_util.h"
#include "wifi_ap_iface.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiApIface::WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
: ifname_(ifname),
instances_(instances),
legacy_hal_(legacy_hal),
iface_util_(iface_util),
is_valid_(true) {}
void WifiApIface::invalidate() {
legacy_hal_.reset();
is_valid_ = false;
}
bool WifiApIface::isValid() {
return is_valid_;
}
std::string WifiApIface::getName() {
return ifname_;
}
void WifiApIface::removeInstance(std::string instance) {
instances_.erase(std::remove(instances_.begin(), instances_.end(), instance), instances_.end());
}
Return<void> WifiApIface::getName(getName_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getNameInternal, hidl_status_cb);
}
Return<void> WifiApIface::getType(getType_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getTypeInternal, hidl_status_cb);
}
Return<void> WifiApIface::setCountryCode(const hidl_array<int8_t, 2>& code,
setCountryCode_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::setCountryCodeInternal, hidl_status_cb, code);
}
Return<void> WifiApIface::getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
}
Return<void> WifiApIface::setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::setMacAddressInternal, hidl_status_cb, mac);
}
Return<void> WifiApIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getFactoryMacAddressInternal, hidl_status_cb,
instances_.size() > 0 ? instances_[0] : ifname_);
}
Return<void> WifiApIface::resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::resetToFactoryMacAddressInternal, hidl_status_cb);
}
Return<void> WifiApIface::getBridgedInstances(getBridgedInstances_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiApIface::getBridgedInstancesInternal, hidl_status_cb);
}
std::pair<WifiStatus, std::string> WifiApIface::getNameInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
}
std::pair<WifiStatus, IfaceType> WifiApIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::AP};
}
WifiStatus WifiApIface::setCountryCodeInternal(const std::array<int8_t, 2>& code) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setCountryCode(
instances_.size() > 0 ? instances_[0] : ifname_, code);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
WifiApIface::getValidFrequenciesForBandInternal(V1_0::WifiBand band) {
static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
legacy_hal::wifi_error legacy_status;
std::vector<uint32_t> valid_frequencies;
std::tie(legacy_status, valid_frequencies) = legacy_hal_.lock()->getValidFrequenciesForBand(
instances_.size() > 0 ? instances_[0] : ifname_,
hidl_struct_util::convertHidlWifiBandToLegacy(band));
return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
}
WifiStatus WifiApIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
// Support random MAC up to 2 interfaces
if (instances_.size() == 2) {
int rbyte = 1;
for (auto const& intf : instances_) {
std::array<uint8_t, 6> rmac = mac;
// reverse the bits to avoid collision
rmac[rbyte] = 0xff - rmac[rbyte];
if (!iface_util_.lock()->setMacAddress(intf, rmac)) {
LOG(INFO) << "Failed to set random mac address on " << intf;
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
rbyte++;
}
}
// It also needs to set mac address for bridged interface, otherwise the mac
// address of bridged interface will be changed after one of instance
// down.
if (!iface_util_.lock()->setMacAddress(ifname_, mac)) {
LOG(ERROR) << "Fail to config MAC for interface " << ifname_;
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
std::pair<WifiStatus, std::array<uint8_t, 6>> WifiApIface::getFactoryMacAddressInternal(
const std::string& ifaceName) {
std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifaceName);
if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), mac};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), mac};
}
WifiStatus WifiApIface::resetToFactoryMacAddressInternal() {
std::pair<WifiStatus, std::array<uint8_t, 6>> getMacResult;
if (instances_.size() == 2) {
for (auto const& intf : instances_) {
getMacResult = getFactoryMacAddressInternal(intf);
LOG(DEBUG) << "Reset MAC to factory MAC on " << intf;
if (getMacResult.first.code != WifiStatusCode::SUCCESS ||
!iface_util_.lock()->setMacAddress(intf, getMacResult.second)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
}
// It needs to set mac address for bridged interface, otherwise the mac
// address of the bridged interface will be changed after one of the
// instance down. Thus we are generating a random MAC address for the
// bridged interface even if we got the request to reset the Factory
// MAC. Since the bridged interface is an internal interface for the
// operation of bpf and others networking operation.
if (!iface_util_.lock()->setMacAddress(ifname_,
iface_util_.lock()->createRandomMacAddress())) {
LOG(ERROR) << "Fail to config MAC for bridged interface " << ifname_;
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
} else {
getMacResult = getFactoryMacAddressInternal(ifname_);
LOG(DEBUG) << "Reset MAC to factory MAC on " << ifname_;
if (getMacResult.first.code != WifiStatusCode::SUCCESS ||
!iface_util_.lock()->setMacAddress(ifname_, getMacResult.second)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
std::pair<WifiStatus, std::vector<hidl_string>> WifiApIface::getBridgedInstancesInternal() {
std::vector<hidl_string> instances;
for (const auto& instance_name : instances_) {
instances.push_back(instance_name);
}
return {createWifiStatus(WifiStatusCode::SUCCESS), instances};
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

89
wifi/1.6/default/wifi_ap_iface.h
View File

@@ -1,89 +0,0 @@
/*
* 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_AP_IFACE_H_
#define WIFI_AP_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.5/IWifiApIface.h>
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a AP Iface instance.
*/
class WifiApIface : public V1_5::IWifiApIface {
public:
WifiApIface(const std::string& ifname, const std::vector<std::string>& instances,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
void removeInstance(std::string instance);
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
Return<void> setCountryCode(const hidl_array<int8_t, 2>& code,
setCountryCode_cb hidl_status_cb) override;
Return<void> getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) override;
Return<void> setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) override;
Return<void> getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) override;
Return<void> resetToFactoryMacAddress(resetToFactoryMacAddress_cb hidl_status_cb) override;
Return<void> getBridgedInstances(getBridgedInstances_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
WifiStatus setCountryCodeInternal(const std::array<int8_t, 2>& code);
std::pair<WifiStatus, std::vector<WifiChannelInMhz>> getValidFrequenciesForBandInternal(
V1_0::WifiBand band);
WifiStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
std::pair<WifiStatus, std::array<uint8_t, 6>> getFactoryMacAddressInternal(
const std::string& ifaceName);
WifiStatus resetToFactoryMacAddressInternal();
std::pair<WifiStatus, std::vector<hidl_string>> getBridgedInstancesInternal();
std::string ifname_;
std::vector<std::string> instances_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiApIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_AP_IFACE_H_

2062
wifi/1.6/default/wifi_chip.cpp
View File

File diff suppressed because it is too large Load Diff

317
wifi/1.6/default/wifi_chip.h
View File

@@ -1,317 +0,0 @@
/*
* 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 deleteApIface(const std::string& if_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_

247
wifi/1.6/default/wifi_feature_flags.cpp
View File

@@ -1,247 +0,0 @@
/*
* 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.
*/
#include <string>
#include <android-base/logging.h>
#include <cutils/properties.h>
#include "wifi_feature_flags.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
using V1_0::ChipModeId;
using V1_0::IWifiChip;
using V1_6::IfaceConcurrencyType;
/* The chip may either have a single mode supporting any number of combinations,
* or a fixed dual-mode (so it involves firmware loading to switch between
* modes) setting. If there is a need to support more modes, it needs to be
* implemented manually in WiFi HAL (see changeFirmwareMode in
* WifiChip::handleChipConfiguration).
*
* Supported combinations are defined in device's makefile, for example:
* WIFI_HAL_INTERFACE_COMBINATIONS := {{{STA, AP}, 1}, {{P2P, NAN}, 1}},
* WIFI_HAL_INTERFACE_COMBINATIONS += {{{STA}, 1}, {{AP}, 2}}
* What means:
* Interface concurrency combination 1: 1 STA or AP and 1 P2P or NAN concurrent iface
* operations.
* Interface concurrency combination 2: 1 STA and 2 AP concurrent iface operations.
*
* For backward compatibility, the following makefile flags can be used to
* generate combinations list:
* - WIFI_HIDL_FEATURE_DUAL_INTERFACE
* - WIFI_HIDL_FEATURE_DISABLE_AP
* - WIFI_HIDL_FEATURE_AWARE
* However, they are ignored if WIFI_HAL_INTERFACE_COMBINATIONS was provided.
* With WIFI_HIDL_FEATURE_DUAL_INTERFACE flag set, there is a single mode with
* two concurrency combinations:
* Interface Concurrency Combination 1: Will support 1 STA and 1 P2P or NAN (optional)
* concurrent iface operations.
* Interface Concurrency Combination 2: Will support 1 STA and 1 AP concurrent
* iface operations.
*
* The only dual-mode configuration supported is for alternating STA and AP
* mode, that may involve firmware reloading. In such case, there are 2 separate
* modes of operation with 1 concurrency combination each:
* Mode 1 (STA mode): Will support 1 STA and 1 P2P or NAN (optional)
* concurrent iface operations.
* Mode 2 (AP mode): Will support 1 AP iface operation.
*
* If Aware is enabled, the concurrency combination will be modified to support either
* P2P or NAN in place of just P2P.
*/
// clang-format off
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS
constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
#elif defined(WIFI_HIDL_FEATURE_DUAL_INTERFACE)
// former V2 (fixed dual interface) setup expressed as V3
constexpr ChipModeId kMainModeId = chip_mode_ids::kV3;
# ifdef WIFI_HIDL_FEATURE_DISABLE_AP
# ifdef WIFI_HIDL_FEATURE_AWARE
// 1 STA + 1 of (P2P or NAN)
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
# else
// 1 STA + 1 P2P
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P}, 1}}
# endif
# else
# ifdef WIFI_HIDL_FEATURE_AWARE
// (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{AP}, 1}},\
{{{STA}, 1}, {{P2P, NAN}, 1}}
# else
// (1 STA + 1 AP) or (1 STA + 1 P2P)
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{AP}, 1}},\
{{{STA}, 1}, {{P2P}, 1}}
# endif
# endif
#else
// V1 (fixed single interface, dual-mode chip)
constexpr ChipModeId kMainModeId = chip_mode_ids::kV1Sta;
# ifdef WIFI_HIDL_FEATURE_AWARE
// 1 STA + 1 of (P2P or NAN)
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P, NAN}, 1}}
# else
// 1 STA + 1 P2P
# define WIFI_HAL_INTERFACE_COMBINATIONS {{{STA}, 1}, {{P2P}, 1}}
# endif
# ifndef WIFI_HIDL_FEATURE_DISABLE_AP
# define WIFI_HAL_INTERFACE_COMBINATIONS_AP {{{AP}, 1}}
# endif
#endif
// clang-format on
/**
* Helper class to convert a collection of combination limits to a combination.
*
* The main point here is to simplify the syntax required by
* WIFI_HAL_INTERFACE_COMBINATIONS.
*/
struct ChipConcurrencyCombination
: public hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombinationLimit> {
ChipConcurrencyCombination(
const std::initializer_list<V1_6::IWifiChip::ChipConcurrencyCombinationLimit> list)
: hidl_vec(list) {}
operator V1_6::IWifiChip::ChipConcurrencyCombination() const { return {*this}; }
static hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombination> make_vec(
const std::initializer_list<ChipConcurrencyCombination> list) {
return hidl_vec<V1_6::IWifiChip::ChipConcurrencyCombination>( //
std::begin(list), std::end(list));
}
};
#define STA IfaceConcurrencyType::STA
#define AP IfaceConcurrencyType::AP
#define AP_BRIDGED IfaceConcurrencyType::AP_BRIDGED
#define P2P IfaceConcurrencyType::P2P
#define NAN IfaceConcurrencyType::NAN
static const std::vector<V1_6::IWifiChip::ChipMode> kChipModesPrimary{
{kMainModeId, ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS})},
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_AP
{chip_mode_ids::kV1Ap,
ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_AP})},
#endif
};
static const std::vector<V1_6::IWifiChip::ChipMode> kChipModesSecondary{
#ifdef WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP
{chip_mode_ids::kV3,
ChipConcurrencyCombination::make_vec({WIFI_HAL_INTERFACE_COMBINATIONS_SECONDARY_CHIP})},
#endif
};
constexpr char kDebugPresetInterfaceCombinationIdxProperty[] =
"persist.vendor.debug.wifi.hal.preset_interface_combination_idx";
// List of pre-defined concurrency combinations that can be enabled at runtime via
// setting the property: "kDebugPresetInterfaceCombinationIdxProperty" to the
// corresponding index value.
static const std::vector<std::pair<std::string, std::vector<V1_6::IWifiChip::ChipMode>>>
kDebugChipModes{// Legacy combination - No STA/AP concurrencies.
// 0 - (1 AP) or (1 STA + 1 of (P2P or NAN))
{"No STA/AP Concurrency",
{{kMainModeId, ChipConcurrencyCombination::make_vec(
{{{{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + AP concurrency
// 1 - (1 STA + 1 AP) or (1 STA + 1 of (P2P or NAN))
{"STA + AP Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency
// 2 - (1 STA + 1 AP) or (2 STA + 1 of (P2P or NAN))
{"Dual STA Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 1}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
// AP + AP + STA concurrency
// 3 - (1 STA + 2 AP) or (1 STA + 1 of (P2P or NAN))
{"Dual AP Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 1}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency and AP + AP + STA concurrency
// 4 - (1 STA + 2 AP) or (2 STA + 1 of (P2P or NAN))
{"Dual STA & Dual AP Concurrency",
{{kMainModeId,
ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{AP}, 2}}, {{{STA}, 2}, {{P2P, NAN}, 1}}})}}},
// STA + STA concurrency
// 5 - (1 STA + 1 AP (bridged or single) | P2P | NAN), or (2 STA))
{"Dual STA or STA plus single other interface",
{{kMainModeId, ChipConcurrencyCombination::make_vec(
{{{{STA}, 1}, {{P2P, NAN, AP, AP_BRIDGED}, 1}},
{{{STA}, 2}}})}}}};
#undef STA
#undef AP
#undef P2P
#undef NAN
#ifdef WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
#pragma message \
"WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION is deprecated; override " \
"'config_wifi_ap_randomization_supported' in " \
"frameworks/base/core/res/res/values/config.xml in the device overlay " \
"instead"
#endif // WIFI_HIDL_FEATURE_DISABLE_AP_MAC_RANDOMIZATION
WifiFeatureFlags::WifiFeatureFlags() {}
std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModesForPrimary() {
std::array<char, PROPERTY_VALUE_MAX> buffer;
auto res = property_get(kDebugPresetInterfaceCombinationIdxProperty, buffer.data(), nullptr);
// Debug property not set, use the device preset concurrency combination.
if (res <= 0) return kChipModesPrimary;
// Debug property set, use one of the debug preset concurrency combination.
unsigned long idx = std::stoul(buffer.data());
if (idx >= kDebugChipModes.size()) {
LOG(ERROR) << "Invalid index set in property: "
<< kDebugPresetInterfaceCombinationIdxProperty;
return kChipModesPrimary;
}
std::string name;
std::vector<V1_6::IWifiChip::ChipMode> chip_modes;
std::tie(name, chip_modes) = kDebugChipModes[idx];
LOG(INFO) << "Using debug chip mode: <" << name
<< "> set via property: " << kDebugPresetInterfaceCombinationIdxProperty;
return chip_modes;
}
std::vector<V1_6::IWifiChip::ChipMode> WifiFeatureFlags::getChipModes(bool is_primary) {
return (is_primary) ? getChipModesForPrimary() : kChipModesSecondary;
}
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

58
wifi/1.6/default/wifi_feature_flags.h
View File

@@ -1,58 +0,0 @@
/*
* 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_FEATURE_FLAGS_H_
#define WIFI_FEATURE_FLAGS_H_
#include <android/hardware/wifi/1.6/IWifiChip.h>
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace feature_flags {
namespace chip_mode_ids {
// These mode ID's should be unique (even across combo versions). Refer to
// handleChipConfiguration() for it's usage.
constexpr V1_0::ChipModeId kInvalid = UINT32_MAX;
// Mode ID's for V1
constexpr V1_0::ChipModeId kV1Sta = 0;
constexpr V1_0::ChipModeId kV1Ap = 1;
// Mode ID for V3
constexpr V1_0::ChipModeId kV3 = 3;
} // namespace chip_mode_ids
class WifiFeatureFlags {
public:
WifiFeatureFlags();
virtual ~WifiFeatureFlags() = default;
virtual std::vector<V1_6::IWifiChip::ChipMode> getChipModes(bool is_primary);
private:
std::vector<V1_6::IWifiChip::ChipMode> getChipModesForPrimary();
};
} // namespace feature_flags
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_FEATURE_FLAGS_H_

176
wifi/1.6/default/wifi_iface_util.cpp
View File

@@ -1,176 +0,0 @@
/*
* Copyright (C) 2019 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.
*/
#include <net/if.h>
#include <cstddef>
#include <iostream>
#include <limits>
#include <random>
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <private/android_filesystem_config.h>
#undef NAN
#include "wifi_iface_util.h"
namespace {
// Constants to set the local bit & clear the multicast bit.
constexpr uint8_t kMacAddressMulticastMask = 0x01;
constexpr uint8_t kMacAddressLocallyAssignedMask = 0x02;
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
WifiIfaceUtil::WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: iface_tool_(iface_tool),
legacy_hal_(legacy_hal),
random_mac_address_(nullptr),
event_handlers_map_() {}
std::array<uint8_t, 6> WifiIfaceUtil::getFactoryMacAddress(const std::string& iface_name) {
return iface_tool_.lock()->GetFactoryMacAddress(iface_name.c_str());
}
bool WifiIfaceUtil::setMacAddress(const std::string& iface_name,
const std::array<uint8_t, 6>& mac) {
#ifndef WIFI_AVOID_IFACE_RESET_MAC_CHANGE
legacy_hal::wifi_error legacy_status;
uint64_t legacy_feature_set;
std::tie(legacy_status, legacy_feature_set) =
legacy_hal_.lock()->getSupportedFeatureSet(iface_name);
if (!(legacy_feature_set & WIFI_FEATURE_DYNAMIC_SET_MAC) &&
!iface_tool_.lock()->SetUpState(iface_name.c_str(), false)) {
LOG(ERROR) << "SetUpState(false) failed.";
return false;
}
#endif
bool success = iface_tool_.lock()->SetMacAddress(iface_name.c_str(), mac);
#ifndef WIFI_AVOID_IFACE_RESET_MAC_CHANGE
if (!(legacy_feature_set & WIFI_FEATURE_DYNAMIC_SET_MAC) &&
!iface_tool_.lock()->SetUpState(iface_name.c_str(), true)) {
LOG(ERROR) << "SetUpState(true) failed. Wait for driver ready.";
// Wait for driver ready and try to set iface UP again
if (legacy_hal_.lock()->waitForDriverReady() != legacy_hal::WIFI_SUCCESS) {
LOG(ERROR) << "SetUpState(true) wait for driver ready failed.";
return false;
}
if (!iface_tool_.lock()->SetUpState(iface_name.c_str(), true)) {
LOG(ERROR) << "SetUpState(true) failed after retry.";
return false;
}
}
#endif
IfaceEventHandlers event_handlers = {};
const auto it = event_handlers_map_.find(iface_name);
if (it != event_handlers_map_.end()) {
event_handlers = it->second;
}
if (event_handlers.on_state_toggle_off_on != nullptr) {
event_handlers.on_state_toggle_off_on(iface_name);
}
if (!success) {
LOG(ERROR) << "SetMacAddress failed on " << iface_name;
} else {
LOG(DEBUG) << "SetMacAddress succeeded on " << iface_name;
}
return success;
}
std::array<uint8_t, 6> WifiIfaceUtil::getOrCreateRandomMacAddress() {
if (random_mac_address_) {
return *random_mac_address_.get();
}
random_mac_address_ = std::make_unique<std::array<uint8_t, 6>>(createRandomMacAddress());
return *random_mac_address_.get();
}
void WifiIfaceUtil::registerIfaceEventHandlers(const std::string& iface_name,
IfaceEventHandlers handlers) {
event_handlers_map_[iface_name] = handlers;
}
void WifiIfaceUtil::unregisterIfaceEventHandlers(const std::string& iface_name) {
event_handlers_map_.erase(iface_name);
}
std::array<uint8_t, 6> WifiIfaceUtil::createRandomMacAddress() {
std::array<uint8_t, 6> address = {};
std::random_device rd;
std::default_random_engine engine(rd());
std::uniform_int_distribution<uint8_t> dist(std::numeric_limits<uint8_t>::min(),
std::numeric_limits<uint8_t>::max());
for (size_t i = 0; i < address.size(); i++) {
address[i] = dist(engine);
}
// Set the local bit and clear the multicast bit.
address[0] |= kMacAddressLocallyAssignedMask;
address[0] &= ~kMacAddressMulticastMask;
return address;
}
bool WifiIfaceUtil::setUpState(const std::string& iface_name, bool request_up) {
if (!iface_tool_.lock()->SetUpState(iface_name.c_str(), request_up)) {
LOG(ERROR) << "SetUpState to " << request_up << " failed";
return false;
}
return true;
}
unsigned WifiIfaceUtil::ifNameToIndex(const std::string& iface_name) {
return if_nametoindex(iface_name.c_str());
}
bool WifiIfaceUtil::createBridge(const std::string& br_name) {
if (!iface_tool_.lock()->createBridge(br_name)) {
return false;
}
if (!iface_tool_.lock()->SetUpState(br_name.c_str(), true)) {
LOG(ERROR) << "bridge SetUpState(true) failed.";
}
return true;
}
bool WifiIfaceUtil::deleteBridge(const std::string& br_name) {
if (!iface_tool_.lock()->SetUpState(br_name.c_str(), false)) {
LOG(INFO) << "SetUpState(false) failed for bridge=" << br_name.c_str();
}
return iface_tool_.lock()->deleteBridge(br_name);
}
bool WifiIfaceUtil::addIfaceToBridge(const std::string& br_name, const std::string& if_name) {
return iface_tool_.lock()->addIfaceToBridge(br_name, if_name);
}
bool WifiIfaceUtil::removeIfaceFromBridge(const std::string& br_name, const std::string& if_name) {
return iface_tool_.lock()->removeIfaceFromBridge(br_name, if_name);
}
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

87
wifi/1.6/default/wifi_iface_util.h
View File

@@ -1,87 +0,0 @@
/*
* Copyright (C) 2019 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_IFACE_UTIL_H_
#define WIFI_IFACE_UTIL_H_
#include <wifi_system/interface_tool.h>
#include <android/hardware/wifi/1.0/IWifi.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace iface_util {
// Iface event handlers.
struct IfaceEventHandlers {
// Callback to be invoked when the iface is set down & up for MAC address
// change.
std::function<void(const std::string& iface_name)> on_state_toggle_off_on;
};
/**
* Util class for common iface operations.
*/
class WifiIfaceUtil {
public:
WifiIfaceUtil(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
virtual ~WifiIfaceUtil() = default;
virtual std::array<uint8_t, 6> getFactoryMacAddress(const std::string& iface_name);
virtual bool setMacAddress(const std::string& iface_name, const std::array<uint8_t, 6>& mac);
// Get or create a random MAC address. The MAC address returned from
// this method will remain the same throughout the lifetime of the HAL
// daemon. (So, changes on every reboot)
virtual std::array<uint8_t, 6> getOrCreateRandomMacAddress();
// Register for any iface event callbacks for the provided interface.
virtual void registerIfaceEventHandlers(const std::string& iface_name,
IfaceEventHandlers handlers);
virtual void unregisterIfaceEventHandlers(const std::string& iface_name);
virtual bool setUpState(const std::string& iface_name, bool request_up);
virtual unsigned ifNameToIndex(const std::string& iface_name);
virtual bool createBridge(const std::string& br_name);
virtual bool deleteBridge(const std::string& br_name);
virtual bool addIfaceToBridge(const std::string& br_name, const std::string& if_name);
virtual bool removeIfaceFromBridge(const std::string& br_name, const std::string& if_name);
// Get a random MAC address.
virtual std::array<uint8_t, 6> createRandomMacAddress();
private:
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::unique_ptr<std::array<uint8_t, 6>> random_mac_address_;
std::map<std::string, IfaceEventHandlers> event_handlers_map_;
};
} // namespace iface_util
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_IFACE_UTIL_H_

1654
wifi/1.6/default/wifi_legacy_hal.cpp
View File

File diff suppressed because it is too large Load Diff

739
wifi/1.6/default/wifi_legacy_hal.h
View File

@@ -1,739 +0,0 @@
/*
* 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_LEGACY_HAL_H_
#define WIFI_LEGACY_HAL_H_
#include <condition_variable>
#include <functional>
#include <map>
#include <thread>
#include <vector>
#include <hal_legacy/wifi_hal.h>
#include <wifi_system/interface_tool.h>
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
// This is in a separate namespace to prevent typename conflicts between
// the legacy HAL types and the HIDL interface types.
namespace legacy_hal {
// Import all the types defined inside the legacy HAL header files into this
// namespace.
using ::chre_nan_rtt_state;
using ::frame_info;
using ::frame_type;
using ::FRAME_TYPE_80211_MGMT;
using ::FRAME_TYPE_ETHERNET_II;
using ::FRAME_TYPE_UNKNOWN;
using ::fw_roaming_state_t;
using ::mac_addr;
using ::NAN_CHANNEL_24G_BAND;
using ::NAN_CHANNEL_5G_BAND_HIGH;
using ::NAN_CHANNEL_5G_BAND_LOW;
using ::NAN_DISABLE_RANGE_REPORT;
using ::NAN_DO_NOT_USE_SRF;
using ::NAN_DP_CHANNEL_NOT_REQUESTED;
using ::NAN_DP_CONFIG_NO_SECURITY;
using ::NAN_DP_CONFIG_SECURITY;
using ::NAN_DP_END;
using ::NAN_DP_FORCE_CHANNEL_SETUP;
using ::NAN_DP_INITIATOR_RESPONSE;
using ::NAN_DP_INTERFACE_CREATE;
using ::NAN_DP_INTERFACE_DELETE;
using ::NAN_DP_REQUEST_ACCEPT;
using ::NAN_DP_REQUEST_CHANNEL_SETUP;
using ::NAN_DP_REQUEST_REJECT;
using ::NAN_DP_RESPONDER_RESPONSE;
using ::NAN_GET_CAPABILITIES;
using ::NAN_MATCH_ALG_MATCH_CONTINUOUS;
using ::NAN_MATCH_ALG_MATCH_NEVER;
using ::NAN_MATCH_ALG_MATCH_ONCE;
using ::NAN_PUBLISH_TYPE_SOLICITED;
using ::NAN_PUBLISH_TYPE_UNSOLICITED;
using ::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
using ::NAN_RANGING_AUTO_RESPONSE_DISABLE;
using ::NAN_RANGING_AUTO_RESPONSE_ENABLE;
using ::NAN_RANGING_DISABLE;
using ::NAN_RANGING_ENABLE;
using ::NAN_RESPONSE_BEACON_SDF_PAYLOAD;
using ::NAN_RESPONSE_CONFIG;
using ::NAN_RESPONSE_DISABLED;
using ::NAN_RESPONSE_ENABLED;
using ::NAN_RESPONSE_ERROR;
using ::NAN_RESPONSE_PUBLISH;
using ::NAN_RESPONSE_PUBLISH_CANCEL;
using ::NAN_RESPONSE_STATS;
using ::NAN_RESPONSE_SUBSCRIBE;
using ::NAN_RESPONSE_SUBSCRIBE_CANCEL;
using ::NAN_RESPONSE_TCA;
using ::NAN_RESPONSE_TRANSMIT_FOLLOWUP;
using ::NAN_SECURITY_KEY_INPUT_PASSPHRASE;
using ::NAN_SECURITY_KEY_INPUT_PMK;
using ::NAN_SERVICE_ACCEPT_POLICY_ALL;
using ::NAN_SERVICE_ACCEPT_POLICY_NONE;
using ::NAN_SRF_ATTR_BLOOM_FILTER;
using ::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
using ::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
using ::NAN_SRF_INCLUDE_RESPOND;
using ::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
using ::NAN_SSI_REQUIRED_IN_MATCH_IND;
using ::NAN_STATUS_ALREADY_ENABLED;
using ::NAN_STATUS_FOLLOWUP_QUEUE_FULL;
using ::NAN_STATUS_INTERNAL_FAILURE;
using ::NAN_STATUS_INVALID_NDP_ID;
using ::NAN_STATUS_INVALID_PARAM;
using ::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID;
using ::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID;
using ::NAN_STATUS_NAN_NOT_ALLOWED;
using ::NAN_STATUS_NO_OTA_ACK;
using ::NAN_STATUS_NO_RESOURCE_AVAILABLE;
using ::NAN_STATUS_PROTOCOL_FAILURE;
using ::NAN_STATUS_SUCCESS;
using ::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED;
using ::NAN_SUBSCRIBE_TYPE_ACTIVE;
using ::NAN_SUBSCRIBE_TYPE_PASSIVE;
using ::NAN_TRANSMIT_IN_DW;
using ::NAN_TRANSMIT_IN_FAW;
using ::NAN_TX_PRIORITY_HIGH;
using ::NAN_TX_PRIORITY_NORMAL;
using ::NAN_TX_TYPE_BROADCAST;
using ::NAN_TX_TYPE_UNICAST;
using ::NAN_USE_SRF;
using ::NanBeaconSdfPayloadInd;
using ::NanCapabilities;
using ::NanChannelInfo;
using ::NanConfigRequest;
using ::NanDataPathChannelCfg;
using ::NanDataPathConfirmInd;
using ::NanDataPathEndInd;
using ::NanDataPathIndicationResponse;
using ::NanDataPathInitiatorRequest;
using ::NanDataPathRequestInd;
using ::NanDataPathScheduleUpdateInd;
using ::NanDisabledInd;
using ::NanDiscEngEventInd;
using ::NanEnableRequest;
using ::NanFollowupInd;
using ::NanMatchAlg;
using ::NanMatchExpiredInd;
using ::NanMatchInd;
using ::NanPublishCancelRequest;
using ::NanPublishRequest;
using ::NanPublishTerminatedInd;
using ::NanPublishType;
using ::NanRangeReportInd;
using ::NanRangeRequestInd;
using ::NanResponseMsg;
using ::NanSRFType;
using ::NanStatusType;
using ::NanSubscribeCancelRequest;
using ::NanSubscribeRequest;
using ::NanSubscribeTerminatedInd;
using ::NanSubscribeType;
using ::NanTransmitFollowupInd;
using ::NanTransmitFollowupRequest;
using ::NanTxType;
using ::ROAMING_DISABLE;
using ::ROAMING_ENABLE;
using ::RTT_PEER_AP;
using ::RTT_PEER_NAN;
using ::RTT_PEER_P2P_CLIENT;
using ::RTT_PEER_P2P_GO;
using ::RTT_PEER_STA;
using ::rtt_peer_type;
using ::RTT_STATUS_ABORTED;
using ::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL;
using ::RTT_STATUS_FAIL_BUSY_TRY_LATER;
using ::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE;
using ::RTT_STATUS_FAIL_INVALID_TS;
using ::RTT_STATUS_FAIL_NO_CAPABILITY;
using ::RTT_STATUS_FAIL_NO_RSP;
using ::RTT_STATUS_FAIL_NOT_SCHEDULED_YET;
using ::RTT_STATUS_FAIL_PROTOCOL;
using ::RTT_STATUS_FAIL_REJECTED;
using ::RTT_STATUS_FAIL_SCHEDULE;
using ::RTT_STATUS_FAIL_TM_TIMEOUT;
using ::RTT_STATUS_FAILURE;
using ::RTT_STATUS_INVALID_REQ;
using ::RTT_STATUS_NAN_RANGING_CONCURRENCY_NOT_SUPPORTED;
using ::RTT_STATUS_NAN_RANGING_PROTOCOL_FAILURE;
using ::RTT_STATUS_NO_WIFI;
using ::RTT_STATUS_SUCCESS;
using ::RTT_TYPE_1_SIDED;
using ::RTT_TYPE_2_SIDED;
using ::RX_PKT_FATE_DRV_DROP_FILTER;
using ::RX_PKT_FATE_DRV_DROP_INVALID;
using ::RX_PKT_FATE_DRV_DROP_NOBUFS;
using ::RX_PKT_FATE_DRV_DROP_OTHER;
using ::RX_PKT_FATE_DRV_QUEUED;
using ::RX_PKT_FATE_FW_DROP_FILTER;
using ::RX_PKT_FATE_FW_DROP_INVALID;
using ::RX_PKT_FATE_FW_DROP_NOBUFS;
using ::RX_PKT_FATE_FW_DROP_OTHER;
using ::RX_PKT_FATE_FW_QUEUED;
using ::RX_PKT_FATE_SUCCESS;
using ::ssid_t;
using ::transaction_id;
using ::TX_PKT_FATE_ACKED;
using ::TX_PKT_FATE_DRV_DROP_INVALID;
using ::TX_PKT_FATE_DRV_DROP_NOBUFS;
using ::TX_PKT_FATE_DRV_DROP_OTHER;
using ::TX_PKT_FATE_DRV_QUEUED;
using ::TX_PKT_FATE_FW_DROP_INVALID;
using ::TX_PKT_FATE_FW_DROP_NOBUFS;
using ::TX_PKT_FATE_FW_DROP_OTHER;
using ::TX_PKT_FATE_FW_QUEUED;
using ::TX_PKT_FATE_SENT;
using ::WIFI_AC_BE;
using ::WIFI_AC_BK;
using ::WIFI_AC_VI;
using ::WIFI_AC_VO;
using ::WIFI_ANTENNA_1X1;
using ::WIFI_ANTENNA_2X2;
using ::WIFI_ANTENNA_3X3;
using ::WIFI_ANTENNA_4X4;
using ::WIFI_ANTENNA_UNSPECIFIED;
using ::wifi_band;
using ::WIFI_BAND_A;
using ::WIFI_BAND_A_DFS;
using ::WIFI_BAND_A_WITH_DFS;
using ::WIFI_BAND_ABG;
using ::WIFI_BAND_ABG_WITH_DFS;
using ::WIFI_BAND_BG;
using ::WIFI_BAND_UNSPECIFIED;
using ::wifi_cached_scan_report;
using ::wifi_cached_scan_results;
using ::WIFI_CHAN_WIDTH_10;
using ::WIFI_CHAN_WIDTH_160;
using ::WIFI_CHAN_WIDTH_20;
using ::WIFI_CHAN_WIDTH_320;
using ::WIFI_CHAN_WIDTH_40;
using ::WIFI_CHAN_WIDTH_5;
using ::WIFI_CHAN_WIDTH_80;
using ::WIFI_CHAN_WIDTH_80P80;
using ::WIFI_CHAN_WIDTH_INVALID;
using ::wifi_channel_info;
using ::wifi_channel_stat;
using ::wifi_channel_width;
using ::wifi_coex_restriction;
using ::wifi_coex_unsafe_channel;
using ::WIFI_DUAL_STA_NON_TRANSIENT_UNBIASED;
using ::WIFI_DUAL_STA_TRANSIENT_PREFER_PRIMARY;
using ::wifi_error;
using ::WIFI_ERROR_BUSY;
using ::WIFI_ERROR_INVALID_ARGS;
using ::WIFI_ERROR_INVALID_REQUEST_ID;
using ::WIFI_ERROR_NONE;
using ::WIFI_ERROR_NOT_AVAILABLE;
using ::WIFI_ERROR_NOT_SUPPORTED;
using ::WIFI_ERROR_OUT_OF_MEMORY;
using ::WIFI_ERROR_TIMED_OUT;
using ::WIFI_ERROR_TOO_MANY_REQUESTS;
using ::WIFI_ERROR_UNINITIALIZED;
using ::WIFI_ERROR_UNKNOWN;
using ::wifi_gscan_capabilities;
using ::wifi_hal_fn;
using ::wifi_information_element;
using ::WIFI_INTERFACE_IBSS;
using ::WIFI_INTERFACE_MESH;
using ::wifi_interface_mode;
using ::WIFI_INTERFACE_NAN;
using ::WIFI_INTERFACE_P2P_CLIENT;
using ::WIFI_INTERFACE_P2P_GO;
using ::WIFI_INTERFACE_SOFTAP;
using ::WIFI_INTERFACE_STA;
using ::WIFI_INTERFACE_TDLS;
using ::wifi_interface_type;
using ::WIFI_INTERFACE_TYPE_AP;
using ::WIFI_INTERFACE_TYPE_NAN;
using ::WIFI_INTERFACE_TYPE_P2P;
using ::WIFI_INTERFACE_TYPE_STA;
using ::WIFI_INTERFACE_UNKNOWN;
using ::wifi_latency_mode;
using ::WIFI_LATENCY_MODE_LOW;
using ::WIFI_LATENCY_MODE_NORMAL;
using ::wifi_lci_information;
using ::wifi_lcr_information;
using ::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED;
using ::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED;
using ::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED;
using ::WIFI_LOGGER_PACKET_FATE_SUPPORTED;
using ::WIFI_LOGGER_POWER_EVENT_SUPPORTED;
using ::WIFI_LOGGER_WAKE_LOCK_SUPPORTED;
using ::WIFI_MOTION_EXPECTED;
using ::WIFI_MOTION_NOT_EXPECTED;
using ::wifi_motion_pattern;
using ::WIFI_MOTION_UNKNOWN;
using ::wifi_multi_sta_use_case;
using ::wifi_power_scenario;
using ::WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF;
using ::WIFI_POWER_SCENARIO_ON_BODY_CELL_ON;
using ::WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF;
using ::WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON;
using ::WIFI_POWER_SCENARIO_VOICE_CALL;
using ::wifi_radio_combination;
using ::wifi_radio_combination_matrix;
using ::wifi_radio_configuration;
using ::wifi_rate;
using ::wifi_request_id;
using ::wifi_ring_buffer_status;
using ::wifi_roaming_capabilities;
using ::wifi_roaming_config;
using ::wifi_rtt_bw;
using ::WIFI_RTT_BW_10;
using ::WIFI_RTT_BW_160;
using ::WIFI_RTT_BW_20;
using ::WIFI_RTT_BW_320;
using ::WIFI_RTT_BW_40;
using ::WIFI_RTT_BW_5;
using ::WIFI_RTT_BW_80;
using ::wifi_rtt_capabilities;
using ::wifi_rtt_config;
using ::wifi_rtt_preamble;
using ::WIFI_RTT_PREAMBLE_EHT;
using ::WIFI_RTT_PREAMBLE_HE;
using ::WIFI_RTT_PREAMBLE_HT;
using ::WIFI_RTT_PREAMBLE_LEGACY;
using ::WIFI_RTT_PREAMBLE_VHT;
using ::wifi_rtt_responder;
using ::wifi_rtt_result;
using ::wifi_rtt_status;
using ::wifi_rtt_type;
using ::wifi_rx_packet_fate;
using ::wifi_rx_report;
using ::wifi_scan_bucket_spec;
using ::wifi_scan_cmd_params;
using ::WIFI_SCAN_FLAG_INTERRUPTED;
using ::wifi_scan_result;
using ::WIFI_SUCCESS;
using ::wifi_tx_packet_fate;
using ::wifi_tx_report;
using ::wifi_usable_channel;
using ::WIFI_USABLE_CHANNEL_FILTER_CELLULAR_COEXISTENCE;
using ::WIFI_USABLE_CHANNEL_FILTER_CONCURRENCY;
using ::WLAN_MAC_2_4_BAND;
using ::WLAN_MAC_5_0_BAND;
using ::WLAN_MAC_60_0_BAND;
using ::WLAN_MAC_6_0_BAND;
// APF capabilities supported by the iface.
struct PacketFilterCapabilities {
uint32_t version;
uint32_t max_len;
};
// WARNING: We don't care about the variable sized members of either
// |wifi_iface_stat|, |wifi_radio_stat| structures. So, using the pragma
// to escape the compiler warnings regarding this.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wgnu-variable-sized-type-not-at-end"
// The |wifi_radio_stat.tx_time_per_levels| stats is provided as a pointer in
// |wifi_radio_stat| structure in the legacy HAL API. Separate that out
// into a separate return element to avoid passing pointers around.
struct LinkLayerRadioStats {
wifi_radio_stat stats;
std::vector<uint32_t> tx_time_per_levels;
std::vector<wifi_channel_stat> channel_stats;
};
struct WifiPeerInfo {
wifi_peer_info peer_info;
std::vector<wifi_rate_stat> rate_stats;
};
struct LinkLayerStats {
wifi_iface_stat iface;
std::vector<LinkLayerRadioStats> radios;
std::vector<WifiPeerInfo> peers;
};
#pragma GCC diagnostic pop
// The |WLAN_DRIVER_WAKE_REASON_CNT.cmd_event_wake_cnt| and
// |WLAN_DRIVER_WAKE_REASON_CNT.driver_fw_local_wake_cnt| stats is provided
// as a pointer in |WLAN_DRIVER_WAKE_REASON_CNT| structure in the legacy HAL
// API. Separate that out into a separate return elements to avoid passing
// pointers around.
struct WakeReasonStats {
WLAN_DRIVER_WAKE_REASON_CNT wake_reason_cnt;
std::vector<uint32_t> cmd_event_wake_cnt;
std::vector<uint32_t> driver_fw_local_wake_cnt;
};
// NAN response and event callbacks struct.
struct NanCallbackHandlers {
// NotifyResponse invoked to notify the status of the Request.
std::function<void(transaction_id, const NanResponseMsg&)> on_notify_response;
// Various event callbacks.
std::function<void(const NanPublishTerminatedInd&)> on_event_publish_terminated;
std::function<void(const NanMatchInd&)> on_event_match;
std::function<void(const NanMatchExpiredInd&)> on_event_match_expired;
std::function<void(const NanSubscribeTerminatedInd&)> on_event_subscribe_terminated;
std::function<void(const NanFollowupInd&)> on_event_followup;
std::function<void(const NanDiscEngEventInd&)> on_event_disc_eng_event;
std::function<void(const NanDisabledInd&)> on_event_disabled;
std::function<void(const NanTCAInd&)> on_event_tca;
std::function<void(const NanBeaconSdfPayloadInd&)> on_event_beacon_sdf_payload;
std::function<void(const NanDataPathRequestInd&)> on_event_data_path_request;
std::function<void(const NanDataPathConfirmInd&)> on_event_data_path_confirm;
std::function<void(const NanDataPathEndInd&)> on_event_data_path_end;
std::function<void(const NanTransmitFollowupInd&)> on_event_transmit_follow_up;
std::function<void(const NanRangeRequestInd&)> on_event_range_request;
std::function<void(const NanRangeReportInd&)> on_event_range_report;
std::function<void(const NanDataPathScheduleUpdateInd&)> on_event_schedule_update;
};
// Full scan results contain IE info and are hence passed by reference, to
// preserve the variable length array member |ie_data|. Callee must not retain
// the pointer.
using on_gscan_full_result_callback =
std::function<void(wifi_request_id, const wifi_scan_result*, uint32_t)>;
// These scan results don't contain any IE info, so no need to pass by
// reference.
using on_gscan_results_callback =
std::function<void(wifi_request_id, const std::vector<wifi_cached_scan_results>&)>;
// Invoked when the rssi value breaches the thresholds set.
using on_rssi_threshold_breached_callback =
std::function<void(wifi_request_id, std::array<uint8_t, 6>, int8_t)>;
// Callback for RTT range request results.
// Rtt results contain IE info and are hence passed by reference, to
// preserve the |LCI| and |LCR| pointers. Callee must not retain
// the pointer.
using on_rtt_results_callback =
std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result*>&)>;
// Callback for ring buffer data.
using on_ring_buffer_data_callback = std::function<void(
const std::string&, const std::vector<uint8_t>&, const wifi_ring_buffer_status&)>;
// Callback for alerts.
using on_error_alert_callback = std::function<void(int32_t, const std::vector<uint8_t>&)>;
// Callback for subsystem restart
using on_subsystem_restart_callback = std::function<void(const std::string&)>;
// Struct for the mac info from the legacy HAL. This is a cleaner version
// of the |wifi_mac_info| & |wifi_iface_info|.
typedef struct {
std::string name;
wifi_channel channel;
} WifiIfaceInfo;
typedef struct {
uint32_t wlan_mac_id;
/* BIT MASK of BIT(WLAN_MAC*) as represented by wlan_mac_band */
uint32_t mac_band;
/* Represents the connected Wi-Fi interfaces associated with each MAC */
std::vector<WifiIfaceInfo> iface_infos;
} WifiMacInfo;
// Callback for radio mode change
using on_radio_mode_change_callback = std::function<void(const std::vector<WifiMacInfo>&)>;
// TWT response and event callbacks struct.
struct TwtCallbackHandlers {
// Callback for TWT setup response
std::function<void(const TwtSetupResponse&)> on_setup_response;
// Callback for TWT teardown completion
std::function<void(const TwtTeardownCompletion&)> on_teardown_completion;
// Callback for TWT info frame received event
std::function<void(const TwtInfoFrameReceived&)> on_info_frame_received;
// Callback for TWT notification from the device
std::function<void(const TwtDeviceNotify&)> on_device_notify;
};
// CHRE response and event callbacks struct.
struct ChreCallbackHandlers {
// Callback for CHRE NAN RTT
std::function<void(chre_nan_rtt_state)> on_wifi_chre_nan_rtt_state;
};
// Cached Scan Results response and event callbacks struct.
struct CachedScanResultsCallbackHandlers {
// Callback for Cached Scan Results
std::function<void(wifi_cached_scan_report*)> on_cached_scan_results;
};
/**
* Class that encapsulates all legacy HAL interactions.
* This class manages the lifetime of the event loop thread used by legacy HAL.
*
* Note: There will only be a single instance of this class created in the Wifi
* object and will be valid for the lifetime of the process.
*/
class WifiLegacyHal {
public:
WifiLegacyHal(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool, const wifi_hal_fn& fn,
bool is_primary);
virtual ~WifiLegacyHal() = default;
// Initialize the legacy HAL function table.
virtual wifi_error initialize();
// Start the legacy HAL and the event looper thread.
virtual wifi_error start();
// Deinitialize the legacy HAL and wait for the event loop thread to exit
// using a predefined timeout.
virtual wifi_error stop(std::unique_lock<std::recursive_mutex>* lock,
const std::function<void()>& on_complete_callback);
virtual wifi_error waitForDriverReady();
// Checks if legacy HAL has successfully started
bool isStarted();
// Wrappers for all the functions in the legacy HAL function table.
virtual std::pair<wifi_error, std::string> getDriverVersion(const std::string& iface_name);
virtual std::pair<wifi_error, std::string> getFirmwareVersion(const std::string& iface_name);
std::pair<wifi_error, std::vector<uint8_t>> requestDriverMemoryDump(
const std::string& iface_name);
std::pair<wifi_error, std::vector<uint8_t>> requestFirmwareMemoryDump(
const std::string& iface_name);
virtual std::pair<wifi_error, uint64_t> getSupportedFeatureSet(const std::string& iface_name);
// APF functions.
std::pair<wifi_error, PacketFilterCapabilities> getPacketFilterCapabilities(
const std::string& iface_name);
wifi_error setPacketFilter(const std::string& iface_name, const std::vector<uint8_t>& program);
std::pair<wifi_error, std::vector<uint8_t>> readApfPacketFilterData(
const std::string& iface_name);
// Gscan functions.
std::pair<wifi_error, wifi_gscan_capabilities> getGscanCapabilities(
const std::string& iface_name);
// These API's provides a simplified interface over the legacy Gscan API's:
// a) All scan events from the legacy HAL API other than the
// |WIFI_SCAN_FAILED| are treated as notification of results.
// This method then retrieves the cached scan results from the legacy
// HAL API and triggers the externally provided
// |on_results_user_callback| on success.
// b) |WIFI_SCAN_FAILED| scan event or failure to retrieve cached scan
// results
// triggers the externally provided |on_failure_user_callback|.
// c) Full scan result event triggers the externally provided
// |on_full_result_user_callback|.
wifi_error startGscan(const std::string& iface_name, wifi_request_id id,
const wifi_scan_cmd_params& params,
const std::function<void(wifi_request_id)>& on_failure_callback,
const on_gscan_results_callback& on_results_callback,
const on_gscan_full_result_callback& on_full_result_callback);
wifi_error stopGscan(const std::string& iface_name, wifi_request_id id);
std::pair<wifi_error, std::vector<uint32_t>> getValidFrequenciesForBand(
const std::string& iface_name, wifi_band band);
virtual wifi_error setDfsFlag(const std::string& iface_name, bool dfs_on);
// Link layer stats functions.
wifi_error enableLinkLayerStats(const std::string& iface_name, bool debug);
wifi_error disableLinkLayerStats(const std::string& iface_name);
std::pair<wifi_error, LinkLayerStats> getLinkLayerStats(const std::string& iface_name);
// RSSI monitor functions.
wifi_error startRssiMonitoring(
const std::string& iface_name, wifi_request_id id, int8_t max_rssi, int8_t min_rssi,
const on_rssi_threshold_breached_callback& on_threshold_breached_callback);
wifi_error stopRssiMonitoring(const std::string& iface_name, wifi_request_id id);
std::pair<wifi_error, wifi_roaming_capabilities> getRoamingCapabilities(
const std::string& iface_name);
wifi_error configureRoaming(const std::string& iface_name, const wifi_roaming_config& config);
wifi_error enableFirmwareRoaming(const std::string& iface_name, fw_roaming_state_t state);
wifi_error configureNdOffload(const std::string& iface_name, bool enable);
wifi_error startSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id,
uint16_t ether_type,
const std::vector<uint8_t>& ip_packet_data,
const std::array<uint8_t, 6>& src_address,
const std::array<uint8_t, 6>& dst_address,
uint32_t period_in_ms);
wifi_error stopSendingOffloadedPacket(const std::string& iface_name, uint32_t cmd_id);
virtual wifi_error selectTxPowerScenario(const std::string& iface_name,
wifi_power_scenario scenario);
virtual wifi_error resetTxPowerScenario(const std::string& iface_name);
wifi_error setLatencyMode(const std::string& iface_name, wifi_latency_mode mode);
wifi_error setThermalMitigationMode(wifi_thermal_mode mode, uint32_t completion_window);
wifi_error setDscpToAccessCategoryMapping(uint32_t start, uint32_t end,
uint32_t access_category);
wifi_error resetDscpToAccessCategoryMapping();
// Logger/debug functions.
std::pair<wifi_error, uint32_t> getLoggerSupportedFeatureSet(const std::string& iface_name);
wifi_error startPktFateMonitoring(const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_tx_report>> getTxPktFates(const std::string& iface_name);
std::pair<wifi_error, std::vector<wifi_rx_report>> getRxPktFates(const std::string& iface_name);
std::pair<wifi_error, WakeReasonStats> getWakeReasonStats(const std::string& iface_name);
wifi_error registerRingBufferCallbackHandler(
const std::string& iface_name, const on_ring_buffer_data_callback& on_data_callback);
wifi_error deregisterRingBufferCallbackHandler(const std::string& iface_name);
virtual wifi_error registerSubsystemRestartCallbackHandler(
const on_subsystem_restart_callback& on_restart_callback);
std::pair<wifi_error, std::vector<wifi_ring_buffer_status>> getRingBuffersStatus(
const std::string& iface_name);
wifi_error startRingBufferLogging(const std::string& iface_name, const std::string& ring_name,
uint32_t verbose_level, uint32_t max_interval_sec,
uint32_t min_data_size);
wifi_error getRingBufferData(const std::string& iface_name, const std::string& ring_name);
wifi_error registerErrorAlertCallbackHandler(const std::string& iface_name,
const on_error_alert_callback& on_alert_callback);
wifi_error deregisterErrorAlertCallbackHandler(const std::string& iface_name);
// Radio mode functions.
virtual wifi_error registerRadioModeChangeCallbackHandler(
const std::string& iface_name,
const on_radio_mode_change_callback& on_user_change_callback);
// RTT functions.
wifi_error startRttRangeRequest(const std::string& iface_name, wifi_request_id id,
const std::vector<wifi_rtt_config>& rtt_configs,
const on_rtt_results_callback& on_results_callback);
wifi_error cancelRttRangeRequest(const std::string& iface_name, wifi_request_id id,
const std::vector<std::array<uint8_t, 6>>& mac_addrs);
std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(const std::string& iface_name);
std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo(const std::string& iface_name);
wifi_error enableRttResponder(const std::string& iface_name, wifi_request_id id,
const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
const wifi_rtt_responder& info);
wifi_error disableRttResponder(const std::string& iface_name, wifi_request_id id);
wifi_error setRttLci(const std::string& iface_name, wifi_request_id id,
const wifi_lci_information& info);
wifi_error setRttLcr(const std::string& iface_name, wifi_request_id id,
const wifi_lcr_information& info);
// NAN functions.
virtual wifi_error nanRegisterCallbackHandlers(const std::string& iface_name,
const NanCallbackHandlers& callbacks);
wifi_error nanEnableRequest(const std::string& iface_name, transaction_id id,
const NanEnableRequest& msg);
virtual wifi_error nanDisableRequest(const std::string& iface_name, transaction_id id);
wifi_error nanPublishRequest(const std::string& iface_name, transaction_id id,
const NanPublishRequest& msg);
wifi_error nanPublishCancelRequest(const std::string& iface_name, transaction_id id,
const NanPublishCancelRequest& msg);
wifi_error nanSubscribeRequest(const std::string& iface_name, transaction_id id,
const NanSubscribeRequest& msg);
wifi_error nanSubscribeCancelRequest(const std::string& iface_name, transaction_id id,
const NanSubscribeCancelRequest& msg);
wifi_error nanTransmitFollowupRequest(const std::string& iface_name, transaction_id id,
const NanTransmitFollowupRequest& msg);
wifi_error nanStatsRequest(const std::string& iface_name, transaction_id id,
const NanStatsRequest& msg);
wifi_error nanConfigRequest(const std::string& iface_name, transaction_id id,
const NanConfigRequest& msg);
wifi_error nanTcaRequest(const std::string& iface_name, transaction_id id,
const NanTCARequest& msg);
wifi_error nanBeaconSdfPayloadRequest(const std::string& iface_name, transaction_id id,
const NanBeaconSdfPayloadRequest& msg);
std::pair<wifi_error, NanVersion> nanGetVersion();
wifi_error nanGetCapabilities(const std::string& iface_name, transaction_id id);
wifi_error nanDataInterfaceCreate(const std::string& iface_name, transaction_id id,
const std::string& data_iface_name);
virtual wifi_error nanDataInterfaceDelete(const std::string& iface_name, transaction_id id,
const std::string& data_iface_name);
wifi_error nanDataRequestInitiator(const std::string& iface_name, transaction_id id,
const NanDataPathInitiatorRequest& msg);
wifi_error nanDataIndicationResponse(const std::string& iface_name, transaction_id id,
const NanDataPathIndicationResponse& msg);
wifi_error nanDataEnd(const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId);
// AP functions.
wifi_error setCountryCode(const std::string& iface_name, std::array<int8_t, 2> code);
// interface functions.
virtual wifi_error createVirtualInterface(const std::string& ifname,
wifi_interface_type iftype);
virtual wifi_error deleteVirtualInterface(const std::string& ifname);
virtual wifi_error getSupportedIfaceName(uint32_t iface_type, std::string& ifname);
// STA + STA functions
virtual wifi_error multiStaSetPrimaryConnection(const std::string& ifname);
virtual wifi_error multiStaSetUseCase(wifi_multi_sta_use_case use_case);
// Coex functions.
virtual wifi_error setCoexUnsafeChannels(std::vector<wifi_coex_unsafe_channel> unsafe_channels,
uint32_t restrictions);
wifi_error setVoipMode(const std::string& iface_name, wifi_voip_mode mode);
wifi_error twtRegisterHandler(const std::string& iface_name,
const TwtCallbackHandlers& handler);
std::pair<wifi_error, TwtCapabilitySet> twtGetCapability(const std::string& iface_name);
wifi_error twtSetupRequest(const std::string& iface_name, const TwtSetupRequest& msg);
wifi_error twtTearDownRequest(const std::string& iface_name, const TwtTeardownRequest& msg);
wifi_error twtInfoFrameRequest(const std::string& iface_name, const TwtInfoFrameRequest& msg);
std::pair<wifi_error, TwtStats> twtGetStats(const std::string& iface_name, uint8_t configId);
wifi_error twtClearStats(const std::string& iface_name, uint8_t configId);
wifi_error setDtimConfig(const std::string& iface_name, uint32_t multiplier);
// Retrieve the list of usable channels in the requested bands
// for the requested modes
std::pair<wifi_error, std::vector<wifi_usable_channel>> getUsableChannels(
uint32_t band_mask, uint32_t iface_mode_mask, uint32_t filter_mask);
wifi_error triggerSubsystemRestart();
wifi_error setIndoorState(bool isIndoor);
std::pair<wifi_error, wifi_radio_combination_matrix*> getSupportedRadioCombinationsMatrix();
// CHRE NAN RTT function
wifi_error chreNanRttRequest(const std::string& iface_name, bool enable);
wifi_error chreRegisterHandler(const std::string& iface_name,
const ChreCallbackHandlers& handler);
wifi_error enableWifiTxPowerLimits(const std::string& iface_name, bool enable);
wifi_error getWifiCachedScanResults(const std::string& iface_name,
const CachedScanResultsCallbackHandlers& handler);
private:
// Retrieve interface handles for all the available interfaces.
wifi_error retrieveIfaceHandles();
wifi_interface_handle getIfaceHandle(const std::string& iface_name);
// Run the legacy HAL event loop thread.
void runEventLoop();
// Retrieve the cached gscan results to pass the results back to the
// external callbacks.
std::pair<wifi_error, std::vector<wifi_cached_scan_results>> getGscanCachedResults(
const std::string& iface_name);
void invalidate();
// Handles wifi (error) status of Virtual interface create/delete
wifi_error handleVirtualInterfaceCreateOrDeleteStatus(const std::string& ifname,
wifi_error status);
// Global function table of legacy HAL.
wifi_hal_fn global_func_table_;
// Opaque handle to be used for all global operations.
wifi_handle global_handle_;
// Map of interface name to handle that is to be used for all interface
// specific operations.
std::map<std::string, wifi_interface_handle> iface_name_to_handle_;
// Flag to indicate if we have initiated the cleanup of legacy HAL.
std::atomic<bool> awaiting_event_loop_termination_;
std::condition_variable_any stop_wait_cv_;
// Flag to indicate if the legacy HAL has been started.
bool is_started_;
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
// flag to indicate if this HAL is for the primary chip. This is used
// in order to avoid some hard-coded behavior used with older HALs,
// such as bring wlan0 interface up/down on start/stop HAL.
// it may be removed once vendor HALs are updated.
bool is_primary_;
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_LEGACY_HAL_H_

254
wifi/1.6/default/wifi_legacy_hal_factory.cpp
View File

@@ -1,254 +0,0 @@
/*
* Copyright (C) 2020 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.
*/
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <android-base/logging.h>
#include <dlfcn.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xmlmemory.h>
#include "wifi_legacy_hal_factory.h"
#include "wifi_legacy_hal_stubs.h"
namespace {
static constexpr char kVendorHalsDescPath[] = "/vendor/etc/wifi/vendor_hals";
static constexpr char kVendorHalsDescExt[] = ".xml";
static constexpr uint32_t kVendorHalsDescVersion = 1;
bool isDirectory(struct dirent* entryPtr) {
bool isDir = false;
if (entryPtr->d_type != DT_UNKNOWN && entryPtr->d_type != DT_LNK) {
isDir = (entryPtr->d_type == DT_DIR);
} else {
struct stat entryStat;
stat(entryPtr->d_name, &entryStat);
isDir = S_ISDIR(entryStat.st_mode);
}
return isDir;
}
bool isFileExtension(const char* name, const char* ext) {
if (name == NULL) return false;
if (ext == NULL) return false;
size_t extLen = strlen(ext);
size_t nameLen = strlen(name);
if (extLen > nameLen) return false;
if (strncmp(name + nameLen - extLen, ext, extLen) != 0) return false;
return true;
}
}; // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
WifiLegacyHalFactory::WifiLegacyHalFactory(
const std::weak_ptr<wifi_system::InterfaceTool> iface_tool)
: iface_tool_(iface_tool) {}
std::vector<std::shared_ptr<WifiLegacyHal>> WifiLegacyHalFactory::getHals() {
if (legacy_hals_.empty()) {
if (!initVendorHalDescriptorFromLinked()) initVendorHalsDescriptorList();
for (auto& desc : descs_) {
std::shared_ptr<WifiLegacyHal> hal =
std::make_shared<WifiLegacyHal>(iface_tool_, desc.fn, desc.primary);
legacy_hals_.push_back(hal);
}
}
return legacy_hals_;
}
bool WifiLegacyHalFactory::initVendorHalDescriptorFromLinked() {
wifi_hal_lib_desc desc;
if (!initLinkedHalFunctionTable(&desc.fn)) return false;
desc.primary = true;
desc.handle = NULL;
descs_.push_back(desc);
return true;
}
bool WifiLegacyHalFactory::initLinkedHalFunctionTable(wifi_hal_fn* hal_fn) {
init_wifi_vendor_hal_func_table_t initfn;
initfn = (init_wifi_vendor_hal_func_table_t)dlsym(RTLD_DEFAULT,
"init_wifi_vendor_hal_func_table");
if (!initfn) {
LOG(INFO) << "no vendor HAL library linked, will try dynamic load";
return false;
}
if (!initHalFuncTableWithStubs(hal_fn)) {
LOG(ERROR) << "Can not initialize the basic function pointer table";
return false;
}
if (initfn(hal_fn) != WIFI_SUCCESS) {
LOG(ERROR) << "Can not initialize the vendor function pointer table";
return false;
}
return true;
}
/*
* Overall structure of the HAL descriptor XML schema
*
* <?xml version="1.0" encoding="UTF-8"?>
* <WifiVendorHal version="1">
* <path>/vendor/lib64/libwifi-hal-qcom.so</path>
* <primary>1</primary>
* </WifiVendorHal>
*/
void WifiLegacyHalFactory::initVendorHalsDescriptorList() {
xmlDocPtr xml;
xmlNodePtr node, cnode;
char* version;
std::string path;
xmlChar* value;
wifi_hal_lib_desc desc;
LOG(INFO) << "processing vendor HALs descriptions in " << kVendorHalsDescPath;
DIR* dirPtr = ::opendir(kVendorHalsDescPath);
if (dirPtr == NULL) {
LOG(ERROR) << "failed to open " << kVendorHalsDescPath;
return;
}
for (struct dirent* entryPtr = ::readdir(dirPtr); entryPtr != NULL;
entryPtr = ::readdir(dirPtr)) {
if (isDirectory(entryPtr)) continue;
if (!isFileExtension(entryPtr->d_name, kVendorHalsDescExt))
continue; // only process .xml files
LOG(INFO) << "processing config file: " << entryPtr->d_name;
std::string fullPath(kVendorHalsDescPath);
fullPath.append("/");
fullPath.append(entryPtr->d_name);
xml = xmlReadFile(fullPath.c_str(), "UTF-8", XML_PARSE_RECOVER);
if (!xml) {
LOG(ERROR) << "failed to parse: " << entryPtr->d_name << " skipping...";
continue;
}
node = xmlDocGetRootElement(xml);
if (!node) {
LOG(ERROR) << "empty config file: " << entryPtr->d_name << " skipping...";
goto skip;
}
if (xmlStrcmp(node->name, BAD_CAST "WifiVendorHal")) {
LOG(ERROR) << "bad config, root element not WifiVendorHal: " << entryPtr->d_name
<< " skipping...";
goto skip;
}
version = (char*)xmlGetProp(node, BAD_CAST "version");
if (!version || strtoul(version, NULL, 0) != kVendorHalsDescVersion) {
LOG(ERROR) << "conf file: " << entryPtr->d_name
<< "must have version: " << kVendorHalsDescVersion << ", skipping...";
goto skip;
}
cnode = node->children;
path.clear();
desc.primary = false;
while (cnode) {
if (!xmlStrcmp(cnode->name, BAD_CAST "path")) {
value = xmlNodeListGetString(xml, cnode->children, 1);
if (value) path = (char*)value;
xmlFree(value);
} else if (!xmlStrcmp(cnode->name, BAD_CAST "primary")) {
value = xmlNodeListGetString(xml, cnode->children, 1);
desc.primary = !xmlStrcmp(value, BAD_CAST "1");
xmlFree(value);
}
cnode = cnode->next;
}
if (path.empty()) {
LOG(ERROR) << "hal library path not provided in: " << entryPtr->d_name
<< ", skipping...";
goto skip;
}
if (loadVendorHalLib(path, desc)) {
if (desc.primary)
descs_.insert(descs_.begin(), desc);
else
descs_.push_back(desc);
}
skip:
xmlFreeDoc(xml);
}
::closedir(dirPtr);
}
bool WifiLegacyHalFactory::loadVendorHalLib(const std::string& path, wifi_hal_lib_desc& desc) {
void* h = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
init_wifi_vendor_hal_func_table_t initfn;
wifi_error res;
if (!h) {
LOG(ERROR) << "failed to open vendor hal library: " << path;
return false;
}
initfn = (init_wifi_vendor_hal_func_table_t)dlsym(h, "init_wifi_vendor_hal_func_table");
if (!initfn) {
LOG(ERROR) << "init_wifi_vendor_hal_func_table not found in: " << path;
goto out_err;
}
if (!initHalFuncTableWithStubs(&desc.fn)) {
LOG(ERROR) << "Can not initialize the basic function pointer table";
goto out_err;
}
res = initfn(&desc.fn);
if (res != WIFI_SUCCESS) {
LOG(ERROR) << "failed to initialize the vendor func table in: " << path
<< " error: " << res;
goto out_err;
}
res = desc.fn.wifi_early_initialize();
// vendor HALs which do not implement early_initialize will return
// WIFI_ERROR_NOT_SUPPORTED, treat this as success.
if (res != WIFI_SUCCESS && res != WIFI_ERROR_NOT_SUPPORTED) {
LOG(ERROR) << "early initialization failed in: " << path << " error: " << res;
goto out_err;
}
desc.handle = h;
return true;
out_err:
dlclose(h);
return false;
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

66
wifi/1.6/default/wifi_legacy_hal_factory.h
View File

@@ -1,66 +0,0 @@
/*
* Copyright (C) 2020 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_LEGACY_HAL_FACTORY_H_
#define WIFI_LEGACY_HAL_FACTORY_H_
#include <wifi_system/interface_tool.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
// This is in a separate namespace to prevent typename conflicts between
// the legacy HAL types and the HIDL interface types.
namespace legacy_hal {
/**
* Class that creates WifiLegacyHal objects for vendor HALs in the system.
*/
class WifiLegacyHalFactory {
public:
WifiLegacyHalFactory(const std::weak_ptr<wifi_system::InterfaceTool> iface_tool);
virtual ~WifiLegacyHalFactory() = default;
std::vector<std::shared_ptr<WifiLegacyHal>> getHals();
private:
typedef struct {
wifi_hal_fn fn;
bool primary;
void* handle;
} wifi_hal_lib_desc;
bool initVendorHalDescriptorFromLinked();
void initVendorHalsDescriptorList();
bool initLinkedHalFunctionTable(wifi_hal_fn* hal_fn);
bool loadVendorHalLib(const std::string& path, wifi_hal_lib_desc& desc);
std::weak_ptr<wifi_system::InterfaceTool> iface_tool_;
std::vector<wifi_hal_lib_desc> descs_;
std::vector<std::shared_ptr<WifiLegacyHal>> legacy_hals_;
};
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_LEGACY_HAL_FACTORY_H_

178
wifi/1.6/default/wifi_legacy_hal_stubs.cpp
View File

@@ -1,178 +0,0 @@
/*
* 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.
*/
#include "wifi_legacy_hal_stubs.h"
// TODO: Remove these stubs from HalTool in libwifi-system.
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
template <typename>
struct stubFunction;
template <typename R, typename... Args>
struct stubFunction<R (*)(Args...)> {
static constexpr R invoke(Args...) { return WIFI_ERROR_NOT_SUPPORTED; }
};
template <typename... Args>
struct stubFunction<void (*)(Args...)> {
static constexpr void invoke(Args...) {}
};
template <typename T>
void populateStubFor(T* val) {
*val = &stubFunction<T>::invoke;
}
bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) {
if (hal_fn == nullptr) {
return false;
}
populateStubFor(&hal_fn->wifi_initialize);
populateStubFor(&hal_fn->wifi_wait_for_driver_ready);
populateStubFor(&hal_fn->wifi_cleanup);
populateStubFor(&hal_fn->wifi_event_loop);
populateStubFor(&hal_fn->wifi_get_error_info);
populateStubFor(&hal_fn->wifi_get_supported_feature_set);
populateStubFor(&hal_fn->wifi_get_concurrency_matrix);
populateStubFor(&hal_fn->wifi_set_scanning_mac_oui);
populateStubFor(&hal_fn->wifi_get_supported_channels);
populateStubFor(&hal_fn->wifi_is_epr_supported);
populateStubFor(&hal_fn->wifi_get_ifaces);
populateStubFor(&hal_fn->wifi_get_iface_name);
populateStubFor(&hal_fn->wifi_set_iface_event_handler);
populateStubFor(&hal_fn->wifi_reset_iface_event_handler);
populateStubFor(&hal_fn->wifi_start_gscan);
populateStubFor(&hal_fn->wifi_stop_gscan);
populateStubFor(&hal_fn->wifi_get_cached_gscan_results);
populateStubFor(&hal_fn->wifi_set_bssid_hotlist);
populateStubFor(&hal_fn->wifi_reset_bssid_hotlist);
populateStubFor(&hal_fn->wifi_set_significant_change_handler);
populateStubFor(&hal_fn->wifi_reset_significant_change_handler);
populateStubFor(&hal_fn->wifi_get_gscan_capabilities);
populateStubFor(&hal_fn->wifi_set_link_stats);
populateStubFor(&hal_fn->wifi_get_link_stats);
populateStubFor(&hal_fn->wifi_clear_link_stats);
populateStubFor(&hal_fn->wifi_get_valid_channels);
populateStubFor(&hal_fn->wifi_rtt_range_request);
populateStubFor(&hal_fn->wifi_rtt_range_cancel);
populateStubFor(&hal_fn->wifi_get_rtt_capabilities);
populateStubFor(&hal_fn->wifi_rtt_get_responder_info);
populateStubFor(&hal_fn->wifi_enable_responder);
populateStubFor(&hal_fn->wifi_disable_responder);
populateStubFor(&hal_fn->wifi_set_nodfs_flag);
populateStubFor(&hal_fn->wifi_start_logging);
populateStubFor(&hal_fn->wifi_set_epno_list);
populateStubFor(&hal_fn->wifi_reset_epno_list);
populateStubFor(&hal_fn->wifi_set_country_code);
populateStubFor(&hal_fn->wifi_get_firmware_memory_dump);
populateStubFor(&hal_fn->wifi_set_log_handler);
populateStubFor(&hal_fn->wifi_reset_log_handler);
populateStubFor(&hal_fn->wifi_set_alert_handler);
populateStubFor(&hal_fn->wifi_reset_alert_handler);
populateStubFor(&hal_fn->wifi_get_firmware_version);
populateStubFor(&hal_fn->wifi_get_ring_buffers_status);
populateStubFor(&hal_fn->wifi_get_logger_supported_feature_set);
populateStubFor(&hal_fn->wifi_get_ring_data);
populateStubFor(&hal_fn->wifi_enable_tdls);
populateStubFor(&hal_fn->wifi_disable_tdls);
populateStubFor(&hal_fn->wifi_get_tdls_status);
populateStubFor(&hal_fn->wifi_get_tdls_capabilities);
populateStubFor(&hal_fn->wifi_get_driver_version);
populateStubFor(&hal_fn->wifi_set_passpoint_list);
populateStubFor(&hal_fn->wifi_reset_passpoint_list);
populateStubFor(&hal_fn->wifi_set_lci);
populateStubFor(&hal_fn->wifi_set_lcr);
populateStubFor(&hal_fn->wifi_start_sending_offloaded_packet);
populateStubFor(&hal_fn->wifi_stop_sending_offloaded_packet);
populateStubFor(&hal_fn->wifi_start_rssi_monitoring);
populateStubFor(&hal_fn->wifi_stop_rssi_monitoring);
populateStubFor(&hal_fn->wifi_get_wake_reason_stats);
populateStubFor(&hal_fn->wifi_configure_nd_offload);
populateStubFor(&hal_fn->wifi_get_driver_memory_dump);
populateStubFor(&hal_fn->wifi_start_pkt_fate_monitoring);
populateStubFor(&hal_fn->wifi_get_tx_pkt_fates);
populateStubFor(&hal_fn->wifi_get_rx_pkt_fates);
populateStubFor(&hal_fn->wifi_nan_enable_request);
populateStubFor(&hal_fn->wifi_nan_disable_request);
populateStubFor(&hal_fn->wifi_nan_publish_request);
populateStubFor(&hal_fn->wifi_nan_publish_cancel_request);
populateStubFor(&hal_fn->wifi_nan_subscribe_request);
populateStubFor(&hal_fn->wifi_nan_subscribe_cancel_request);
populateStubFor(&hal_fn->wifi_nan_transmit_followup_request);
populateStubFor(&hal_fn->wifi_nan_stats_request);
populateStubFor(&hal_fn->wifi_nan_config_request);
populateStubFor(&hal_fn->wifi_nan_tca_request);
populateStubFor(&hal_fn->wifi_nan_beacon_sdf_payload_request);
populateStubFor(&hal_fn->wifi_nan_register_handler);
populateStubFor(&hal_fn->wifi_nan_get_version);
populateStubFor(&hal_fn->wifi_nan_get_capabilities);
populateStubFor(&hal_fn->wifi_nan_data_interface_create);
populateStubFor(&hal_fn->wifi_nan_data_interface_delete);
populateStubFor(&hal_fn->wifi_nan_data_request_initiator);
populateStubFor(&hal_fn->wifi_nan_data_indication_response);
populateStubFor(&hal_fn->wifi_nan_data_end);
populateStubFor(&hal_fn->wifi_get_packet_filter_capabilities);
populateStubFor(&hal_fn->wifi_set_packet_filter);
populateStubFor(&hal_fn->wifi_read_packet_filter);
populateStubFor(&hal_fn->wifi_get_roaming_capabilities);
populateStubFor(&hal_fn->wifi_enable_firmware_roaming);
populateStubFor(&hal_fn->wifi_configure_roaming);
populateStubFor(&hal_fn->wifi_select_tx_power_scenario);
populateStubFor(&hal_fn->wifi_reset_tx_power_scenario);
populateStubFor(&hal_fn->wifi_set_radio_mode_change_handler);
populateStubFor(&hal_fn->wifi_set_latency_mode);
populateStubFor(&hal_fn->wifi_set_thermal_mitigation_mode);
populateStubFor(&hal_fn->wifi_virtual_interface_create);
populateStubFor(&hal_fn->wifi_virtual_interface_delete);
populateStubFor(&hal_fn->wifi_map_dscp_access_category);
populateStubFor(&hal_fn->wifi_reset_dscp_mapping);
populateStubFor(&hal_fn->wifi_set_subsystem_restart_handler);
populateStubFor(&hal_fn->wifi_get_supported_iface_name);
populateStubFor(&hal_fn->wifi_early_initialize);
populateStubFor(&hal_fn->wifi_get_chip_feature_set);
populateStubFor(&hal_fn->wifi_multi_sta_set_primary_connection);
populateStubFor(&hal_fn->wifi_multi_sta_set_use_case);
populateStubFor(&hal_fn->wifi_set_coex_unsafe_channels);
populateStubFor(&hal_fn->wifi_set_voip_mode);
populateStubFor(&hal_fn->wifi_twt_register_handler);
populateStubFor(&hal_fn->wifi_twt_get_capability);
populateStubFor(&hal_fn->wifi_twt_setup_request);
populateStubFor(&hal_fn->wifi_twt_teardown_request);
populateStubFor(&hal_fn->wifi_twt_info_frame_request);
populateStubFor(&hal_fn->wifi_twt_get_stats);
populateStubFor(&hal_fn->wifi_twt_clear_stats);
populateStubFor(&hal_fn->wifi_set_dtim_config);
populateStubFor(&hal_fn->wifi_get_usable_channels);
populateStubFor(&hal_fn->wifi_trigger_subsystem_restart);
populateStubFor(&hal_fn->wifi_set_indoor_state);
populateStubFor(&hal_fn->wifi_get_supported_radio_combinations_matrix);
populateStubFor(&hal_fn->wifi_nan_rtt_chre_enable_request);
populateStubFor(&hal_fn->wifi_nan_rtt_chre_disable_request);
populateStubFor(&hal_fn->wifi_chre_register_handler);
populateStubFor(&hal_fn->wifi_enable_tx_power_limits);
populateStubFor(&hal_fn->wifi_get_cached_scan_results);
return true;
}
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

37
wifi/1.6/default/wifi_legacy_hal_stubs.h
View File

@@ -1,37 +0,0 @@
/*
* 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_LEGACY_HAL_STUBS_H_
#define WIFI_LEGACY_HAL_STUBS_H_
#include <hal_legacy/wifi_hal.h>
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace legacy_hal {
bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn);
} // namespace legacy_hal
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_LEGACY_HAL_STUBS_H_

89
wifi/1.6/default/wifi_mode_controller.cpp
View File

@@ -1,89 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <private/android_filesystem_config.h>
#include "wifi_mode_controller.h"
using android::hardware::wifi::V1_0::IfaceType;
using android::wifi_hal::DriverTool;
namespace {
int convertIfaceTypeToFirmwareMode(IfaceType type) {
int mode;
switch (type) {
case IfaceType::AP:
mode = DriverTool::kFirmwareModeAp;
break;
case IfaceType::P2P:
mode = DriverTool::kFirmwareModeP2p;
break;
case IfaceType::NAN:
// NAN is exposed in STA mode currently.
mode = DriverTool::kFirmwareModeSta;
break;
case IfaceType::STA:
mode = DriverTool::kFirmwareModeSta;
break;
}
return mode;
}
} // namespace
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
WifiModeController::WifiModeController() : driver_tool_(new DriverTool) {}
bool WifiModeController::isFirmwareModeChangeNeeded(IfaceType type) {
return driver_tool_->IsFirmwareModeChangeNeeded(convertIfaceTypeToFirmwareMode(type));
}
bool WifiModeController::initialize() {
if (!driver_tool_->LoadDriver()) {
LOG(ERROR) << "Failed to load WiFi driver";
return false;
}
return true;
}
bool WifiModeController::changeFirmwareMode(IfaceType type) {
if (!driver_tool_->ChangeFirmwareMode(convertIfaceTypeToFirmwareMode(type))) {
LOG(ERROR) << "Failed to change firmware mode";
return false;
}
return true;
}
bool WifiModeController::deinitialize() {
if (!driver_tool_->UnloadDriver()) {
LOG(ERROR) << "Failed to unload WiFi driver";
return false;
}
return true;
}
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

63
wifi/1.6/default/wifi_mode_controller.h
View File

@@ -1,63 +0,0 @@
/*
* 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_MODE_CONTROLLER_H_
#define WIFI_MODE_CONTROLLER_H_
#include <wifi_hal/driver_tool.h>
#include <android/hardware/wifi/1.0/IWifi.h>
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
namespace mode_controller {
using namespace android::hardware::wifi::V1_0;
/**
* Class that encapsulates all firmware mode configuration.
* This class will perform the necessary firmware reloads to put the chip in the
* required state (essentially a wrapper over DriverTool).
*/
class WifiModeController {
public:
WifiModeController();
virtual ~WifiModeController() = default;
// Checks if a firmware mode change is necessary to support the specified
// iface type operations.
virtual bool isFirmwareModeChangeNeeded(IfaceType type);
virtual bool initialize();
// Change the firmware mode to support the specified iface type operations.
virtual bool changeFirmwareMode(IfaceType type);
// Unload the driver. This should be invoked whenever |IWifi.stop()| is
// invoked.
virtual bool deinitialize();
private:
std::unique_ptr<wifi_hal::DriverTool> driver_tool_;
};
} // namespace mode_controller
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_MODE_CONTROLLER_H_

1018
wifi/1.6/default/wifi_nan_iface.cpp
View File

File diff suppressed because it is too large Load Diff

208
wifi/1.6/default/wifi_nan_iface.h
View File

@@ -1,208 +0,0 @@
/*
* 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_NAN_IFACE_H_
#define WIFI_NAN_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.6/IWifiNanIface.h>
#include <android/hardware/wifi/1.6/IWifiNanIfaceEventCallback.h>
#include "hidl_callback_util.h"
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
using namespace android::hardware::wifi::V1_2;
using namespace android::hardware::wifi::V1_4;
using namespace android::hardware::wifi::V1_6;
/**
* HIDL interface object used to control a NAN Iface instance.
*/
class WifiNanIface : public V1_6::IWifiNanIface {
public:
WifiNanIface(const std::string& ifname, bool is_dedicated_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
Return<void> registerEventCallback(const sp<V1_0::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> getCapabilitiesRequest(uint16_t cmd_id,
getCapabilitiesRequest_cb hidl_status_cb) override;
Return<void> enableRequest(uint16_t cmd_id, const V1_0::NanEnableRequest& msg,
enableRequest_cb hidl_status_cb) override;
Return<void> configRequest(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
configRequest_cb hidl_status_cb) override;
Return<void> disableRequest(uint16_t cmd_id, disableRequest_cb hidl_status_cb) override;
Return<void> startPublishRequest(uint16_t cmd_id, const V1_0::NanPublishRequest& msg,
startPublishRequest_cb hidl_status_cb) override;
Return<void> stopPublishRequest(uint16_t cmd_id, uint8_t sessionId,
stopPublishRequest_cb hidl_status_cb) override;
Return<void> startSubscribeRequest(uint16_t cmd_id, const V1_0::NanSubscribeRequest& msg,
startSubscribeRequest_cb hidl_status_cb) override;
Return<void> stopSubscribeRequest(uint16_t cmd_id, uint8_t sessionId,
stopSubscribeRequest_cb hidl_status_cb) override;
Return<void> transmitFollowupRequest(uint16_t cmd_id, const NanTransmitFollowupRequest& msg,
transmitFollowupRequest_cb hidl_status_cb) override;
Return<void> createDataInterfaceRequest(uint16_t cmd_id, const hidl_string& iface_name,
createDataInterfaceRequest_cb hidl_status_cb) override;
Return<void> deleteDataInterfaceRequest(uint16_t cmd_id, const hidl_string& iface_name,
deleteDataInterfaceRequest_cb hidl_status_cb) override;
Return<void> initiateDataPathRequest(uint16_t cmd_id,
const V1_0::NanInitiateDataPathRequest& msg,
initiateDataPathRequest_cb hidl_status_cb) override;
Return<void> respondToDataPathIndicationRequest(
uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg,
respondToDataPathIndicationRequest_cb hidl_status_cb) override;
Return<void> terminateDataPathRequest(uint16_t cmd_id, uint32_t ndpInstanceId,
terminateDataPathRequest_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_2(const sp<V1_2::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_2_cb hidl_status_cb) override;
Return<void> enableRequest_1_2(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
enableRequest_1_2_cb hidl_status_cb) override;
Return<void> configRequest_1_2(uint16_t cmd_id, const V1_0::NanConfigRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
configRequest_1_2_cb hidl_status_cb) override;
Return<void> enableRequest_1_4(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
enableRequest_1_4_cb hidl_status_cb) override;
Return<void> configRequest_1_4(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2,
configRequest_1_4_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_5(const sp<V1_5::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_5_cb hidl_status_cb) override;
Return<void> enableRequest_1_5(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2,
enableRequest_1_5_cb hidl_status_cb) override;
Return<void> configRequest_1_5(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2,
configRequest_1_5_cb hidl_status_cb) override;
Return<void> getCapabilitiesRequest_1_5(uint16_t cmd_id,
getCapabilitiesRequest_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_6(const sp<V1_6::IWifiNanIfaceEventCallback>& callback,
registerEventCallback_1_6_cb hidl_status_cb) override;
Return<void> initiateDataPathRequest_1_6(
uint16_t cmd_id, const V1_6::NanInitiateDataPathRequest& msg,
initiateDataPathRequest_1_6_cb hidl_status_cb) override;
Return<void> respondToDataPathIndicationRequest_1_6(
uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg,
respondToDataPathIndicationRequest_1_6_cb hidl_status_cb) override;
Return<void> enableRequest_1_6(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_6::NanConfigRequestSupplemental& msg2,
enableRequest_1_6_cb hidl_status_cb) override;
Return<void> configRequest_1_6(uint16_t cmd_id, const V1_4::NanConfigRequest& msg1,
const V1_6::NanConfigRequestSupplemental& msg2,
configRequest_1_6_cb hidl_status_cb) override;
Return<void> startPublishRequest_1_6(uint16_t cmd_id, const V1_6::NanPublishRequest& msg,
startPublishRequest_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
WifiStatus registerEventCallbackInternal(const sp<V1_0::IWifiNanIfaceEventCallback>& callback);
WifiStatus getCapabilitiesRequestInternal(uint16_t cmd_id);
WifiStatus enableRequestInternal(uint16_t cmd_id, const V1_0::NanEnableRequest& msg);
WifiStatus configRequestInternal(uint16_t cmd_id, const V1_0::NanConfigRequest& msg);
WifiStatus disableRequestInternal(uint16_t cmd_id);
WifiStatus startPublishRequestInternal(uint16_t cmd_id, const V1_0::NanPublishRequest& msg);
WifiStatus stopPublishRequestInternal(uint16_t cmd_id, uint8_t sessionId);
WifiStatus startSubscribeRequestInternal(uint16_t cmd_id, const V1_0::NanSubscribeRequest& msg);
WifiStatus stopSubscribeRequestInternal(uint16_t cmd_id, uint8_t sessionId);
WifiStatus transmitFollowupRequestInternal(uint16_t cmd_id,
const NanTransmitFollowupRequest& msg);
WifiStatus createDataInterfaceRequestInternal(uint16_t cmd_id, const std::string& iface_name);
WifiStatus deleteDataInterfaceRequestInternal(uint16_t cmd_id, const std::string& iface_name);
WifiStatus initiateDataPathRequestInternal(uint16_t cmd_id,
const V1_0::NanInitiateDataPathRequest& msg);
WifiStatus respondToDataPathIndicationRequestInternal(
uint16_t cmd_id, const V1_0::NanRespondToDataPathIndicationRequest& msg);
WifiStatus terminateDataPathRequestInternal(uint16_t cmd_id, uint32_t ndpInstanceId);
WifiStatus registerEventCallback_1_2Internal(
const sp<V1_2::IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_2Internal(uint16_t cmd_id, const V1_0::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_2Internal(uint16_t cmd_id, const V1_0::NanConfigRequest& msg,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus enableRequest_1_4Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_4Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const V1_2::NanConfigRequestSupplemental& msg2);
WifiStatus registerEventCallback_1_5Internal(
const sp<V1_5::IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_5Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_5::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_5Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const V1_5::NanConfigRequestSupplemental& msg2);
WifiStatus getCapabilitiesRequest_1_5Internal(uint16_t cmd_id);
WifiStatus registerEventCallback_1_6Internal(
const sp<V1_6::IWifiNanIfaceEventCallback>& callback);
WifiStatus enableRequest_1_6Internal(uint16_t cmd_id, const V1_4::NanEnableRequest& msg1,
const V1_6::NanConfigRequestSupplemental& msg2);
WifiStatus configRequest_1_6Internal(uint16_t cmd_id, const V1_4::NanConfigRequest& msg,
const V1_6::NanConfigRequestSupplemental& msg2);
WifiStatus startPublishRequest_1_6Internal(uint16_t cmd_id, const V1_6::NanPublishRequest& msg);
WifiStatus initiateDataPathRequest_1_6Internal(uint16_t cmd_id,
const V1_6::NanInitiateDataPathRequest& msg);
WifiStatus respondToDataPathIndicationRequest_1_6Internal(
uint16_t cmd_id, const V1_6::NanRespondToDataPathIndicationRequest& msg);
// all 1_0 and descendant callbacks
std::set<sp<V1_0::IWifiNanIfaceEventCallback>> getEventCallbacks();
// all 1_2 and descendant callbacks
std::set<sp<V1_2::IWifiNanIfaceEventCallback>> getEventCallbacks_1_2();
// all 1_5 and descendant callbacks
std::set<sp<V1_5::IWifiNanIfaceEventCallback>> getEventCallbacks_1_5();
// all 1_6 and descendant callbacks
std::set<sp<V1_6::IWifiNanIfaceEventCallback>> getEventCallbacks_1_6();
std::string ifname_;
bool is_dedicated_iface_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
hidl_callback_util::HidlCallbackHandler<V1_0::IWifiNanIfaceEventCallback> event_cb_handler_;
hidl_callback_util::HidlCallbackHandler<V1_2::IWifiNanIfaceEventCallback> event_cb_handler_1_2_;
hidl_callback_util::HidlCallbackHandler<V1_5::IWifiNanIfaceEventCallback> event_cb_handler_1_5_;
hidl_callback_util::HidlCallbackHandler<V1_6::IWifiNanIfaceEventCallback> event_cb_handler_1_6_;
DISALLOW_COPY_AND_ASSIGN(WifiNanIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_NAN_IFACE_H_

69
wifi/1.6/default/wifi_p2p_iface.cpp
View File

@@ -1,69 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "wifi_p2p_iface.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiP2pIface::WifiP2pIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {}
void WifiP2pIface::invalidate() {
legacy_hal_.reset();
is_valid_ = false;
}
bool WifiP2pIface::isValid() {
return is_valid_;
}
std::string WifiP2pIface::getName() {
return ifname_;
}
Return<void> WifiP2pIface::getName(getName_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiP2pIface::getNameInternal, hidl_status_cb);
}
Return<void> WifiP2pIface::getType(getType_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiP2pIface::getTypeInternal, hidl_status_cb);
}
std::pair<WifiStatus, std::string> WifiP2pIface::getNameInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
}
std::pair<WifiStatus, IfaceType> WifiP2pIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::P2P};
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

66
wifi/1.6/default/wifi_p2p_iface.h
View File

@@ -1,66 +0,0 @@
/*
* 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_P2P_IFACE_H_
#define WIFI_P2P_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.0/IWifiP2pIface.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a P2P Iface instance.
*/
class WifiP2pIface : public V1_0::IWifiP2pIface {
public:
WifiP2pIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::string getName();
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
std::string ifname_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiP2pIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_P2P_IFACE_H_

377
wifi/1.6/default/wifi_rtt_controller.cpp
View File

@@ -1,377 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "hidl_struct_util.h"
#include "wifi_rtt_controller.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiRttController::WifiRttController(const std::string& iface_name,
const sp<IWifiIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
: ifname_(iface_name), bound_iface_(bound_iface), legacy_hal_(legacy_hal), is_valid_(true) {}
void WifiRttController::invalidate() {
legacy_hal_.reset();
event_callbacks_.clear();
is_valid_ = false;
}
bool WifiRttController::isValid() {
return is_valid_;
}
std::vector<sp<V1_6::IWifiRttControllerEventCallback>> WifiRttController::getEventCallbacks() {
return event_callbacks_;
}
std::string WifiRttController::getIfaceName() {
return ifname_;
}
Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getBoundIfaceInternal, hidl_status_cb);
}
Return<void> WifiRttController::registerEventCallback(
const sp<V1_0::IWifiRttControllerEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal, hidl_status_cb,
callback);
}
Return<void> WifiRttController::rangeRequest(uint32_t cmd_id,
const hidl_vec<V1_0::RttConfig>& rtt_configs,
rangeRequest_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal, hidl_status_cb, cmd_id,
rtt_configs);
}
Return<void> WifiRttController::rangeCancel(uint32_t cmd_id,
const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
rangeCancel_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeCancelInternal, hidl_status_cb, cmd_id, addrs);
}
Return<void> WifiRttController::getCapabilities(getCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiRttController::setLci(uint32_t cmd_id, const RttLciInformation& lci,
setLci_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::setLciInternal, hidl_status_cb, cmd_id, lci);
}
Return<void> WifiRttController::setLcr(uint32_t cmd_id, const RttLcrInformation& lcr,
setLcr_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::setLcrInternal, hidl_status_cb, cmd_id, lcr);
}
Return<void> WifiRttController::getResponderInfo(getResponderInfo_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal, hidl_status_cb);
}
Return<void> WifiRttController::enableResponder(uint32_t cmd_id,
const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_0::RttResponder& info,
enableResponder_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal, hidl_status_cb, cmd_id,
channel_hint, max_duration_seconds, info);
}
Return<void> WifiRttController::disableResponder(uint32_t cmd_id,
disableResponder_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::disableResponderInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiRttController::registerEventCallback_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal_1_4, hidl_status_cb,
callback);
}
Return<void> WifiRttController::rangeRequest_1_4(uint32_t cmd_id,
const hidl_vec<V1_4::RttConfig>& rtt_configs,
rangeRequest_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal_1_4, hidl_status_cb, cmd_id,
rtt_configs);
}
Return<void> WifiRttController::getCapabilities_1_4(getCapabilities_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal_1_4, hidl_status_cb);
}
Return<void> WifiRttController::getResponderInfo_1_4(getResponderInfo_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal_1_4, hidl_status_cb);
}
Return<void> WifiRttController::enableResponder_1_4(uint32_t cmd_id,
const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_4::RttResponder& info,
enableResponder_1_4_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal_1_4, hidl_status_cb, cmd_id,
channel_hint, max_duration_seconds, info);
}
Return<void> WifiRttController::registerEventCallback_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::registerEventCallbackInternal_1_6, hidl_status_cb,
callback);
}
Return<void> WifiRttController::rangeRequest_1_6(uint32_t cmd_id,
const hidl_vec<V1_6::RttConfig>& rtt_configs,
rangeRequest_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::rangeRequestInternal_1_6, hidl_status_cb, cmd_id,
rtt_configs);
}
Return<void> WifiRttController::getCapabilities_1_6(getCapabilities_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getCapabilitiesInternal_1_6, hidl_status_cb);
}
Return<void> WifiRttController::getResponderInfo_1_6(getResponderInfo_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::getResponderInfoInternal_1_6, hidl_status_cb);
}
Return<void> WifiRttController::enableResponder_1_6(uint32_t cmd_id,
const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_6::RttResponder& info,
enableResponder_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
&WifiRttController::enableResponderInternal_1_6, hidl_status_cb, cmd_id,
channel_hint, max_duration_seconds, info);
}
std::pair<WifiStatus, sp<IWifiIface>> WifiRttController::getBoundIfaceInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_};
}
WifiStatus WifiRttController::registerEventCallbackInternal(
const sp<V1_0::IWifiRttControllerEventCallback>& /* callback */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiRttController::rangeRequestInternal(
uint32_t /* cmd_id */, const std::vector<V1_0::RttConfig>& /* rtt_configs */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiRttController::rangeCancelInternal(
uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs) {
std::vector<std::array<uint8_t, 6>> legacy_addrs;
for (const auto& addr : addrs) {
legacy_addrs.push_back(addr);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, legacy_addrs);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_0::RttCapabilities> WifiRttController::getCapabilitiesInternal() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
WifiStatus WifiRttController::setLciInternal(uint32_t cmd_id, const RttLciInformation& lci) {
legacy_hal::wifi_lci_information legacy_lci;
if (!hidl_struct_util::convertHidlRttLciInformationToLegacy(lci, &legacy_lci)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiRttController::setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr) {
legacy_hal::wifi_lcr_information legacy_lcr;
if (!hidl_struct_util::convertHidlRttLcrInformationToLegacy(lcr, &legacy_lcr)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_0::RttResponder> WifiRttController::getResponderInfoInternal() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
WifiStatus WifiRttController::enableResponderInternal(
uint32_t /* cmd_id */, const V1_0::WifiChannelInfo& /* channel_hint */,
uint32_t /* max_duration_seconds */, const V1_0::RttResponder& /* info */) {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED)};
}
WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiRttController::registerEventCallbackInternal_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& /* callback */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiRttController::rangeRequestInternal_1_4(
uint32_t /* cmd_id */, const std::vector<V1_4::RttConfig>& /* rtt_configs */) {
// Deprecated support for this api
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
std::pair<WifiStatus, V1_4::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_4() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_4::RttResponder> WifiRttController::getResponderInfoInternal_1_4() {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
WifiStatus WifiRttController::enableResponderInternal_1_4(
uint32_t /* cmd_id */, const V1_0::WifiChannelInfo& /* channel_hint */,
uint32_t /* max_duration_seconds */, const V1_4::RttResponder& /* info */) {
// Deprecated support for this api
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED)};
}
WifiStatus WifiRttController::registerEventCallbackInternal_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback) {
// TODO(b/31632518): remove the callback when the client is destroyed
event_callbacks_.emplace_back(callback);
return createWifiStatus(WifiStatusCode::SUCCESS);
}
WifiStatus WifiRttController::rangeRequestInternal_1_6(
uint32_t cmd_id, const std::vector<V1_6::RttConfig>& rtt_configs) {
std::vector<legacy_hal::wifi_rtt_config> legacy_configs;
if (!hidl_struct_util::convertHidlVectorOfRttConfigToLegacy(rtt_configs, &legacy_configs)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
android::wp<WifiRttController> weak_ptr_this(this);
const auto& on_results_callback =
[weak_ptr_this](legacy_hal::wifi_request_id id,
const std::vector<const legacy_hal::wifi_rtt_result*>& results) {
const auto shared_ptr_this = weak_ptr_this.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
std::vector<V1_6::RttResult> hidl_results;
if (!hidl_struct_util::convertLegacyVectorOfRttResultToHidl(results,
&hidl_results)) {
LOG(ERROR) << "Failed to convert rtt results to HIDL structs";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onResults_1_6(id, hidl_results).isOk()) {
LOG(ERROR) << "Failed to invoke the callback";
}
}
};
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequest(
ifname_, cmd_id, legacy_configs, on_results_callback);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_6::RttCapabilities> WifiRttController::getCapabilitiesInternal_1_6() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_capabilities legacy_caps;
std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
V1_6::RttCapabilities hidl_caps;
if (!hidl_struct_util::convertLegacyRttCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
}
std::pair<WifiStatus, V1_6::RttResponder> WifiRttController::getResponderInfoInternal_1_6() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_responder legacy_responder;
std::tie(legacy_status, legacy_responder) = legacy_hal_.lock()->getRttResponderInfo(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
V1_6::RttResponder hidl_responder;
if (!hidl_struct_util::convertLegacyRttResponderToHidl(legacy_responder, &hidl_responder)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_responder};
}
WifiStatus WifiRttController::enableResponderInternal_1_6(uint32_t cmd_id,
const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_6::RttResponder& info) {
legacy_hal::wifi_channel_info legacy_channel_info;
if (!hidl_struct_util::convertHidlWifiChannelInfoToLegacy(channel_hint, &legacy_channel_info)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_rtt_responder legacy_responder;
if (!hidl_struct_util::convertHidlRttResponderToLegacy(info, &legacy_responder)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(
ifname_, cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);
return createWifiStatusFromLegacyError(legacy_status);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

138
wifi/1.6/default/wifi_rtt_controller.h
View File

@@ -1,138 +0,0 @@
/*
* 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_RTT_CONTROLLER_H_
#define WIFI_RTT_CONTROLLER_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.0/IWifiIface.h>
#include <android/hardware/wifi/1.6/IWifiRttController.h>
#include <android/hardware/wifi/1.6/IWifiRttControllerEventCallback.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
/**
* HIDL interface object used to control all RTT operations.
*/
class WifiRttController : public V1_6::IWifiRttController {
public:
WifiRttController(const std::string& iface_name, const sp<IWifiIface>& bound_iface,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::vector<sp<V1_6::IWifiRttControllerEventCallback>> getEventCallbacks();
std::string getIfaceName();
// HIDL methods exposed.
Return<void> getBoundIface(getBoundIface_cb hidl_status_cb) override;
Return<void> registerEventCallback(const sp<V1_0::IWifiRttControllerEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> rangeRequest(uint32_t cmd_id, const hidl_vec<V1_0::RttConfig>& rtt_configs,
rangeRequest_cb hidl_status_cb) override;
Return<void> rangeCancel(uint32_t cmd_id, const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
rangeCancel_cb hidl_status_cb) override;
Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
Return<void> setLci(uint32_t cmd_id, const RttLciInformation& lci,
setLci_cb hidl_status_cb) override;
Return<void> setLcr(uint32_t cmd_id, const RttLcrInformation& lcr,
setLcr_cb hidl_status_cb) override;
Return<void> getResponderInfo(getResponderInfo_cb hidl_status_cb) override;
Return<void> enableResponder(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_0::RttResponder& info,
enableResponder_cb hidl_status_cb) override;
Return<void> disableResponder(uint32_t cmd_id, disableResponder_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_4_cb hidl_status_cb) override;
Return<void> rangeRequest_1_4(uint32_t cmd_id, const hidl_vec<V1_4::RttConfig>& rtt_configs,
rangeRequest_1_4_cb hidl_status_cb) override;
Return<void> getCapabilities_1_4(getCapabilities_1_4_cb hidl_status_cb) override;
Return<void> getResponderInfo_1_4(getResponderInfo_1_4_cb hidl_status_cb) override;
Return<void> enableResponder_1_4(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_4::RttResponder& info,
enableResponder_1_4_cb hidl_status_cb) override;
Return<void> registerEventCallback_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback,
registerEventCallback_1_6_cb hidl_status_cb) override;
Return<void> rangeRequest_1_6(uint32_t cmd_id, const hidl_vec<V1_6::RttConfig>& rtt_configs,
rangeRequest_1_6_cb hidl_status_cb) override;
Return<void> getCapabilities_1_6(getCapabilities_1_6_cb hidl_status_cb) override;
Return<void> getResponderInfo_1_6(getResponderInfo_1_6_cb hidl_status_cb) override;
Return<void> enableResponder_1_6(uint32_t cmd_id, const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds, const V1_6::RttResponder& info,
enableResponder_1_6_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, sp<IWifiIface>> getBoundIfaceInternal();
WifiStatus registerEventCallbackInternal(
const sp<V1_0::IWifiRttControllerEventCallback>& callback);
WifiStatus rangeRequestInternal(uint32_t cmd_id,
const std::vector<V1_0::RttConfig>& rtt_configs);
WifiStatus rangeCancelInternal(uint32_t cmd_id,
const std::vector<hidl_array<uint8_t, 6>>& addrs);
std::pair<WifiStatus, V1_0::RttCapabilities> getCapabilitiesInternal();
WifiStatus setLciInternal(uint32_t cmd_id, const RttLciInformation& lci);
WifiStatus setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr);
std::pair<WifiStatus, V1_0::RttResponder> getResponderInfoInternal();
WifiStatus enableResponderInternal(uint32_t cmd_id, const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_0::RttResponder& info);
WifiStatus disableResponderInternal(uint32_t cmd_id);
WifiStatus registerEventCallbackInternal_1_4(
const sp<V1_4::IWifiRttControllerEventCallback>& callback);
WifiStatus rangeRequestInternal_1_4(uint32_t cmd_id,
const std::vector<V1_4::RttConfig>& rtt_configs);
std::pair<WifiStatus, V1_4::RttCapabilities> getCapabilitiesInternal_1_4();
std::pair<WifiStatus, V1_4::RttResponder> getResponderInfoInternal_1_4();
WifiStatus enableResponderInternal_1_4(uint32_t cmd_id,
const V1_0::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_4::RttResponder& info);
WifiStatus registerEventCallbackInternal_1_6(
const sp<V1_6::IWifiRttControllerEventCallback>& callback);
WifiStatus rangeRequestInternal_1_6(uint32_t cmd_id,
const std::vector<V1_6::RttConfig>& rtt_configs);
std::pair<WifiStatus, V1_6::RttCapabilities> getCapabilitiesInternal_1_6();
std::pair<WifiStatus, V1_6::RttResponder> getResponderInfoInternal_1_6();
WifiStatus enableResponderInternal_1_6(uint32_t cmd_id,
const V1_6::WifiChannelInfo& channel_hint,
uint32_t max_duration_seconds,
const V1_6::RttResponder& info);
std::string ifname_;
sp<IWifiIface> bound_iface_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::vector<sp<V1_6::IWifiRttControllerEventCallback>> event_callbacks_;
bool is_valid_;
DISALLOW_COPY_AND_ASSIGN(WifiRttController);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_RTT_CONTROLLER_H_

592
wifi/1.6/default/wifi_sta_iface.cpp
View File

@@ -1,592 +0,0 @@
/*
* 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.
*/
#include <android-base/logging.h>
#include "hidl_return_util.h"
#include "hidl_struct_util.h"
#include "wifi_sta_iface.h"
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using hidl_return_util::validateAndCall;
WifiStaIface::WifiStaIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util)
: ifname_(ifname), legacy_hal_(legacy_hal), iface_util_(iface_util), is_valid_(true) {
// Turn on DFS channel usage for STA iface.
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setDfsFlag(ifname_, true);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable.";
}
}
void WifiStaIface::invalidate() {
legacy_hal_.reset();
event_cb_handler_.invalidate();
is_valid_ = false;
}
bool WifiStaIface::isValid() {
return is_valid_;
}
std::string WifiStaIface::getName() {
return ifname_;
}
std::set<sp<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
return event_cb_handler_.getCallbacks();
}
Return<void> WifiStaIface::getName(getName_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getNameInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getTypeInternal, hidl_status_cb);
}
Return<void> WifiStaIface::registerEventCallback(const sp<IWifiStaIfaceEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::registerEventCallbackInternal, hidl_status_cb, callback);
}
Return<void> WifiStaIface::getCapabilities(getCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getApfPacketFilterCapabilities(
getApfPacketFilterCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getApfPacketFilterCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::installApfPacketFilter(uint32_t cmd_id, const hidl_vec<uint8_t>& program,
installApfPacketFilter_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::installApfPacketFilterInternal, hidl_status_cb, cmd_id,
program);
}
Return<void> WifiStaIface::readApfPacketFilterData(readApfPacketFilterData_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::readApfPacketFilterDataInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getBackgroundScanCapabilities(
getBackgroundScanCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getBackgroundScanCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getValidFrequenciesForBand(
V1_0::WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getValidFrequenciesForBandInternal, hidl_status_cb, band);
}
Return<void> WifiStaIface::startBackgroundScan(uint32_t cmd_id,
const StaBackgroundScanParameters& params,
startBackgroundScan_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::startBackgroundScanInternal, hidl_status_cb, cmd_id,
params);
}
Return<void> WifiStaIface::stopBackgroundScan(uint32_t cmd_id,
stopBackgroundScan_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::stopBackgroundScanInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiStaIface::enableLinkLayerStatsCollection(
bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::enableLinkLayerStatsCollectionInternal, hidl_status_cb,
debug);
}
Return<void> WifiStaIface::disableLinkLayerStatsCollection(
disableLinkLayerStatsCollection_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::disableLinkLayerStatsCollectionInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats_1_3(getLinkLayerStats_1_3_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal_1_3, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats_1_5(getLinkLayerStats_1_5_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal_1_5, hidl_status_cb);
}
Return<void> WifiStaIface::getLinkLayerStats_1_6(getLinkLayerStats_1_6_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getLinkLayerStatsInternal_1_6, hidl_status_cb);
}
Return<void> WifiStaIface::startRssiMonitoring(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi,
startRssiMonitoring_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::startRssiMonitoringInternal, hidl_status_cb, cmd_id,
max_rssi, min_rssi);
}
Return<void> WifiStaIface::stopRssiMonitoring(uint32_t cmd_id,
stopRssiMonitoring_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::stopRssiMonitoringInternal, hidl_status_cb, cmd_id);
}
Return<void> WifiStaIface::getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getRoamingCapabilitiesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::configureRoaming(const StaRoamingConfig& config,
configureRoaming_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::configureRoamingInternal, hidl_status_cb, config);
}
Return<void> WifiStaIface::setRoamingState(StaRoamingState state,
setRoamingState_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::setRoamingStateInternal, hidl_status_cb, state);
}
Return<void> WifiStaIface::enableNdOffload(bool enable, enableNdOffload_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::enableNdOffloadInternal, hidl_status_cb, enable);
}
Return<void> WifiStaIface::startSendingKeepAlivePackets(
uint32_t cmd_id, const hidl_vec<uint8_t>& ip_packet_data, uint16_t ether_type,
const hidl_array<uint8_t, 6>& src_address, const hidl_array<uint8_t, 6>& dst_address,
uint32_t period_in_ms, startSendingKeepAlivePackets_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::startSendingKeepAlivePacketsInternal, hidl_status_cb,
cmd_id, ip_packet_data, ether_type, src_address, dst_address,
period_in_ms);
}
Return<void> WifiStaIface::stopSendingKeepAlivePackets(
uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::stopSendingKeepAlivePacketsInternal, hidl_status_cb,
cmd_id);
}
Return<void> WifiStaIface::setScanningMacOui(const hidl_array<uint8_t, 3>& oui,
setScanningMacOui_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::setScanningMacOuiInternal, hidl_status_cb, oui);
}
Return<void> WifiStaIface::startDebugPacketFateMonitoring(
startDebugPacketFateMonitoring_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::startDebugPacketFateMonitoringInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getDebugTxPacketFatesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::getDebugRxPacketFates(getDebugRxPacketFates_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getDebugRxPacketFatesInternal, hidl_status_cb);
}
Return<void> WifiStaIface::setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::setMacAddressInternal, hidl_status_cb, mac);
}
Return<void> WifiStaIface::getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::getFactoryMacAddressInternal, hidl_status_cb);
}
Return<void> WifiStaIface::setScanMode(bool enable, setScanMode_cb hidl_status_cb) {
return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
&WifiStaIface::setScanModeInternal, hidl_status_cb, enable);
}
std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
}
std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() {
return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::STA};
}
WifiStatus WifiStaIface::registerEventCallbackInternal(
const sp<IWifiStaIfaceEventCallback>& callback) {
if (!event_cb_handler_.addCallback(callback)) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
std::pair<WifiStatus, uint32_t> WifiStaIface::getCapabilitiesInternal() {
legacy_hal::wifi_error legacy_status;
uint64_t legacy_feature_set;
std::tie(legacy_status, legacy_feature_set) =
legacy_hal_.lock()->getSupportedFeatureSet(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), 0};
}
uint32_t legacy_logger_feature_set;
std::tie(legacy_status, legacy_logger_feature_set) =
legacy_hal_.lock()->getLoggerSupportedFeatureSet(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
// some devices don't support querying logger feature set
legacy_logger_feature_set = 0;
}
uint32_t hidl_caps;
if (!hidl_struct_util::convertLegacyFeaturesToHidlStaCapabilities(
legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
}
std::pair<WifiStatus, StaApfPacketFilterCapabilities>
WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
legacy_hal::wifi_error legacy_status;
legacy_hal::PacketFilterCapabilities legacy_caps;
std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getPacketFilterCapabilities(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
StaApfPacketFilterCapabilities hidl_caps;
if (!hidl_struct_util::convertLegacyApfCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
}
WifiStatus WifiStaIface::installApfPacketFilterInternal(uint32_t /* cmd_id */,
const std::vector<uint8_t>& program) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->setPacketFilter(ifname_, program);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, std::vector<uint8_t>> WifiStaIface::readApfPacketFilterDataInternal() {
const std::pair<legacy_hal::wifi_error, std::vector<uint8_t>> legacy_status_and_data =
legacy_hal_.lock()->readApfPacketFilterData(ifname_);
return {createWifiStatusFromLegacyError(legacy_status_and_data.first),
std::move(legacy_status_and_data.second)};
}
std::pair<WifiStatus, StaBackgroundScanCapabilities>
WifiStaIface::getBackgroundScanCapabilitiesInternal() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_gscan_capabilities legacy_caps;
std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getGscanCapabilities(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
StaBackgroundScanCapabilities hidl_caps;
if (!hidl_struct_util::convertLegacyGscanCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
}
std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
WifiStaIface::getValidFrequenciesForBandInternal(V1_0::WifiBand band) {
static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
legacy_hal::wifi_error legacy_status;
std::vector<uint32_t> valid_frequencies;
std::tie(legacy_status, valid_frequencies) = legacy_hal_.lock()->getValidFrequenciesForBand(
ifname_, hidl_struct_util::convertHidlWifiBandToLegacy(band));
return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
}
WifiStatus WifiStaIface::startBackgroundScanInternal(uint32_t cmd_id,
const StaBackgroundScanParameters& params) {
legacy_hal::wifi_scan_cmd_params legacy_params;
if (!hidl_struct_util::convertHidlGscanParamsToLegacy(params, &legacy_params)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
android::wp<WifiStaIface> weak_ptr_this(this);
const auto& on_failure_callback = [weak_ptr_this](legacy_hal::wifi_request_id id) {
const auto shared_ptr_this = weak_ptr_this.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onBackgroundScanFailure(id).isOk()) {
LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback";
}
}
};
const auto& on_results_callback =
[weak_ptr_this](legacy_hal::wifi_request_id id,
const std::vector<legacy_hal::wifi_cached_scan_results>& results) {
const auto shared_ptr_this = weak_ptr_this.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
std::vector<StaScanData> hidl_scan_datas;
if (!hidl_struct_util::convertLegacyVectorOfCachedGscanResultsToHidl(
results, &hidl_scan_datas)) {
LOG(ERROR) << "Failed to convert scan results to HIDL structs";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onBackgroundScanResults(id, hidl_scan_datas).isOk()) {
LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback";
}
}
};
const auto& on_full_result_callback = [weak_ptr_this](
legacy_hal::wifi_request_id id,
const legacy_hal::wifi_scan_result* result,
uint32_t buckets_scanned) {
const auto shared_ptr_this = weak_ptr_this.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
StaScanResult hidl_scan_result;
if (!hidl_struct_util::convertLegacyGscanResultToHidl(*result, true, &hidl_scan_result)) {
LOG(ERROR) << "Failed to convert full scan results to HIDL structs";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onBackgroundFullScanResult(id, buckets_scanned, hidl_scan_result)
.isOk()) {
LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
}
}
};
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->startGscan(ifname_, cmd_id, legacy_params, on_failure_callback,
on_results_callback, on_full_result_callback);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableLinkLayerStats(ifname_, debug);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->disableLinkLayerStats(ifname_);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, V1_0::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal() {
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_3::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_3() {
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_5::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_5() {
return {createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED), {}};
}
std::pair<WifiStatus, V1_6::StaLinkLayerStats> WifiStaIface::getLinkLayerStatsInternal_1_6() {
legacy_hal::wifi_error legacy_status;
legacy_hal::LinkLayerStats legacy_stats;
std::tie(legacy_status, legacy_stats) = legacy_hal_.lock()->getLinkLayerStats(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
V1_6::StaLinkLayerStats hidl_stats;
if (!hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats, &hidl_stats)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
}
WifiStatus WifiStaIface::startRssiMonitoringInternal(uint32_t cmd_id, int32_t max_rssi,
int32_t min_rssi) {
android::wp<WifiStaIface> weak_ptr_this(this);
const auto& on_threshold_breached_callback = [weak_ptr_this](legacy_hal::wifi_request_id id,
std::array<uint8_t, 6> bssid,
int8_t rssi) {
const auto shared_ptr_this = weak_ptr_this.promote();
if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
LOG(ERROR) << "Callback invoked on an invalid object";
return;
}
for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
if (!callback->onRssiThresholdBreached(id, bssid, rssi).isOk()) {
LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback";
}
}
};
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRssiMonitoring(
ifname_, cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::stopRssiMonitoringInternal(uint32_t cmd_id) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopRssiMonitoring(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, StaRoamingCapabilities> WifiStaIface::getRoamingCapabilitiesInternal() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_roaming_capabilities legacy_caps;
std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRoamingCapabilities(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
StaRoamingCapabilities hidl_caps;
if (!hidl_struct_util::convertLegacyRoamingCapabilitiesToHidl(legacy_caps, &hidl_caps)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
}
WifiStatus WifiStaIface::configureRoamingInternal(const StaRoamingConfig& config) {
legacy_hal::wifi_roaming_config legacy_config;
if (!hidl_struct_util::convertHidlRoamingConfigToLegacy(config, &legacy_config)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->configureRoaming(ifname_, legacy_config);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableFirmwareRoaming(
ifname_, hidl_struct_util::convertHidlRoamingStateToLegacy(state));
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::enableNdOffloadInternal(bool enable) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->configureNdOffload(ifname_, enable);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::startSendingKeepAlivePacketsInternal(
uint32_t cmd_id, const std::vector<uint8_t>& ip_packet_data, uint16_t ether_type,
const std::array<uint8_t, 6>& src_address, const std::array<uint8_t, 6>& dst_address,
uint32_t period_in_ms) {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startSendingOffloadedPacket(
ifname_, cmd_id, ether_type, ip_packet_data, src_address, dst_address, period_in_ms);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(uint32_t cmd_id) {
legacy_hal::wifi_error legacy_status =
legacy_hal_.lock()->stopSendingOffloadedPacket(ifname_, cmd_id);
return createWifiStatusFromLegacyError(legacy_status);
}
WifiStatus WifiStaIface::setScanningMacOuiInternal(const std::array<uint8_t, 3>& /* oui */) {
// deprecated.
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startPktFateMonitoring(ifname_);
return createWifiStatusFromLegacyError(legacy_status);
}
std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
WifiStaIface::getDebugTxPacketFatesInternal() {
legacy_hal::wifi_error legacy_status;
std::vector<legacy_hal::wifi_tx_report> legacy_fates;
std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getTxPktFates(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
std::vector<WifiDebugTxPacketFateReport> hidl_fates;
if (!hidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToHidl(legacy_fates,
&hidl_fates)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
}
std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
WifiStaIface::getDebugRxPacketFatesInternal() {
legacy_hal::wifi_error legacy_status;
std::vector<legacy_hal::wifi_rx_report> legacy_fates;
std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getRxPktFates(ifname_);
if (legacy_status != legacy_hal::WIFI_SUCCESS) {
return {createWifiStatusFromLegacyError(legacy_status), {}};
}
std::vector<WifiDebugRxPacketFateReport> hidl_fates;
if (!hidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToHidl(legacy_fates,
&hidl_fates)) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
}
WifiStatus WifiStaIface::setMacAddressInternal(const std::array<uint8_t, 6>& mac) {
bool status = iface_util_.lock()->setMacAddress(ifname_, mac);
if (!status) {
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
}
return createWifiStatus(WifiStatusCode::SUCCESS);
}
std::pair<WifiStatus, std::array<uint8_t, 6>> WifiStaIface::getFactoryMacAddressInternal() {
std::array<uint8_t, 6> mac = iface_util_.lock()->getFactoryMacAddress(ifname_);
if (mac[0] == 0 && mac[1] == 0 && mac[2] == 0 && mac[3] == 0 && mac[4] == 0 && mac[5] == 0) {
return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), mac};
}
return {createWifiStatus(WifiStatusCode::SUCCESS), mac};
}
WifiStatus WifiStaIface::setScanModeInternal(bool enable) {
// OEM's need to implement this on their devices if needed.
LOG(WARNING) << "setScanModeInternal(" << enable << ") not supported";
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

157
wifi/1.6/default/wifi_sta_iface.h
View File

@@ -1,157 +0,0 @@
/*
* 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_STA_IFACE_H_
#define WIFI_STA_IFACE_H_
#include <android-base/macros.h>
#include <android/hardware/wifi/1.0/IWifiStaIfaceEventCallback.h>
#include <android/hardware/wifi/1.6/IWifiStaIface.h>
#include "hidl_callback_util.h"
#include "wifi_iface_util.h"
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
/**
* HIDL interface object used to control a STA Iface instance.
*/
class WifiStaIface : public V1_6::IWifiStaIface {
public:
WifiStaIface(const std::string& ifname,
const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
const std::weak_ptr<iface_util::WifiIfaceUtil> iface_util);
// Refer to |WifiChip::invalidate()|.
void invalidate();
bool isValid();
std::set<sp<IWifiStaIfaceEventCallback>> getEventCallbacks();
std::string getName();
// HIDL methods exposed.
Return<void> getName(getName_cb hidl_status_cb) override;
Return<void> getType(getType_cb hidl_status_cb) override;
Return<void> registerEventCallback(const sp<IWifiStaIfaceEventCallback>& callback,
registerEventCallback_cb hidl_status_cb) override;
Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
Return<void> getApfPacketFilterCapabilities(
getApfPacketFilterCapabilities_cb hidl_status_cb) override;
Return<void> installApfPacketFilter(uint32_t cmd_id, const hidl_vec<uint8_t>& program,
installApfPacketFilter_cb hidl_status_cb) override;
Return<void> readApfPacketFilterData(readApfPacketFilterData_cb hidl_status_cb) override;
Return<void> getBackgroundScanCapabilities(
getBackgroundScanCapabilities_cb hidl_status_cb) override;
Return<void> getValidFrequenciesForBand(V1_0::WifiBand band,
getValidFrequenciesForBand_cb hidl_status_cb) override;
Return<void> startBackgroundScan(uint32_t cmd_id, const StaBackgroundScanParameters& params,
startBackgroundScan_cb hidl_status_cb) override;
Return<void> stopBackgroundScan(uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) override;
Return<void> enableLinkLayerStatsCollection(
bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) override;
Return<void> disableLinkLayerStatsCollection(
disableLinkLayerStatsCollection_cb hidl_status_cb) override;
Return<void> getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb) override;
Return<void> getLinkLayerStats_1_3(getLinkLayerStats_1_3_cb hidl_status_cb) override;
Return<void> getLinkLayerStats_1_5(getLinkLayerStats_1_5_cb hidl_status_cb) override;
Return<void> getLinkLayerStats_1_6(getLinkLayerStats_1_6_cb hidl_status_cb) override;
Return<void> startRssiMonitoring(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi,
startRssiMonitoring_cb hidl_status_cb) override;
Return<void> stopRssiMonitoring(uint32_t cmd_id, stopRssiMonitoring_cb hidl_status_cb) override;
Return<void> getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb) override;
Return<void> configureRoaming(const StaRoamingConfig& config,
configureRoaming_cb hidl_status_cb) override;
Return<void> setRoamingState(StaRoamingState state, setRoamingState_cb hidl_status_cb) override;
Return<void> enableNdOffload(bool enable, enableNdOffload_cb hidl_status_cb) override;
Return<void> startSendingKeepAlivePackets(
uint32_t cmd_id, const hidl_vec<uint8_t>& ip_packet_data, uint16_t ether_type,
const hidl_array<uint8_t, 6>& src_address, const hidl_array<uint8_t, 6>& dst_address,
uint32_t period_in_ms, startSendingKeepAlivePackets_cb hidl_status_cb) override;
Return<void> stopSendingKeepAlivePackets(
uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) override;
Return<void> setScanningMacOui(const hidl_array<uint8_t, 3>& oui,
setScanningMacOui_cb hidl_status_cb) override;
Return<void> startDebugPacketFateMonitoring(
startDebugPacketFateMonitoring_cb hidl_status_cb) override;
Return<void> getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb) override;
Return<void> getDebugRxPacketFates(getDebugRxPacketFates_cb hidl_status_cb) override;
Return<void> setMacAddress(const hidl_array<uint8_t, 6>& mac,
setMacAddress_cb hidl_status_cb) override;
Return<void> getFactoryMacAddress(getFactoryMacAddress_cb hidl_status_cb) override;
Return<void> setScanMode(bool enable, setScanMode_cb hidl_status_cb) override;
private:
// Corresponding worker functions for the HIDL methods.
std::pair<WifiStatus, std::string> getNameInternal();
std::pair<WifiStatus, IfaceType> getTypeInternal();
WifiStatus registerEventCallbackInternal(const sp<IWifiStaIfaceEventCallback>& callback);
std::pair<WifiStatus, uint32_t> getCapabilitiesInternal();
std::pair<WifiStatus, StaApfPacketFilterCapabilities> getApfPacketFilterCapabilitiesInternal();
WifiStatus installApfPacketFilterInternal(uint32_t cmd_id, const std::vector<uint8_t>& program);
std::pair<WifiStatus, std::vector<uint8_t>> readApfPacketFilterDataInternal();
std::pair<WifiStatus, StaBackgroundScanCapabilities> getBackgroundScanCapabilitiesInternal();
std::pair<WifiStatus, std::vector<WifiChannelInMhz>> getValidFrequenciesForBandInternal(
V1_0::WifiBand band);
WifiStatus startBackgroundScanInternal(uint32_t cmd_id,
const StaBackgroundScanParameters& params);
WifiStatus stopBackgroundScanInternal(uint32_t cmd_id);
WifiStatus enableLinkLayerStatsCollectionInternal(bool debug);
WifiStatus disableLinkLayerStatsCollectionInternal();
std::pair<WifiStatus, V1_0::StaLinkLayerStats> getLinkLayerStatsInternal();
std::pair<WifiStatus, V1_3::StaLinkLayerStats> getLinkLayerStatsInternal_1_3();
std::pair<WifiStatus, V1_5::StaLinkLayerStats> getLinkLayerStatsInternal_1_5();
std::pair<WifiStatus, V1_6::StaLinkLayerStats> getLinkLayerStatsInternal_1_6();
WifiStatus startRssiMonitoringInternal(uint32_t cmd_id, int32_t max_rssi, int32_t min_rssi);
WifiStatus stopRssiMonitoringInternal(uint32_t cmd_id);
std::pair<WifiStatus, StaRoamingCapabilities> getRoamingCapabilitiesInternal();
WifiStatus configureRoamingInternal(const StaRoamingConfig& config);
WifiStatus setRoamingStateInternal(StaRoamingState state);
WifiStatus enableNdOffloadInternal(bool enable);
WifiStatus startSendingKeepAlivePacketsInternal(uint32_t cmd_id,
const std::vector<uint8_t>& ip_packet_data,
uint16_t ether_type,
const std::array<uint8_t, 6>& src_address,
const std::array<uint8_t, 6>& dst_address,
uint32_t period_in_ms);
WifiStatus stopSendingKeepAlivePacketsInternal(uint32_t cmd_id);
WifiStatus setScanningMacOuiInternal(const std::array<uint8_t, 3>& oui);
WifiStatus startDebugPacketFateMonitoringInternal();
std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>> getDebugTxPacketFatesInternal();
std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>> getDebugRxPacketFatesInternal();
WifiStatus setMacAddressInternal(const std::array<uint8_t, 6>& mac);
std::pair<WifiStatus, std::array<uint8_t, 6>> getFactoryMacAddressInternal();
WifiStatus setScanModeInternal(bool enable);
std::string ifname_;
std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal_;
std::weak_ptr<iface_util::WifiIfaceUtil> iface_util_;
bool is_valid_;
hidl_callback_util::HidlCallbackHandler<IWifiStaIfaceEventCallback> event_cb_handler_;
DISALLOW_COPY_AND_ASSIGN(WifiStaIface);
};
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_STA_IFACE_H_

106
wifi/1.6/default/wifi_status_util.cpp
View File

@@ -1,106 +0,0 @@
/*
* 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.
*/
#include "wifi_status_util.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
std::string legacyErrorToString(legacy_hal::wifi_error error) {
switch (error) {
case legacy_hal::WIFI_SUCCESS:
return "SUCCESS";
case legacy_hal::WIFI_ERROR_UNINITIALIZED:
return "UNINITIALIZED";
case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
return "NOT_AVAILABLE";
case legacy_hal::WIFI_ERROR_NOT_SUPPORTED:
return "NOT_SUPPORTED";
case legacy_hal::WIFI_ERROR_INVALID_ARGS:
return "INVALID_ARGS";
case legacy_hal::WIFI_ERROR_INVALID_REQUEST_ID:
return "INVALID_REQUEST_ID";
case legacy_hal::WIFI_ERROR_TIMED_OUT:
return "TIMED_OUT";
case legacy_hal::WIFI_ERROR_TOO_MANY_REQUESTS:
return "TOO_MANY_REQUESTS";
case legacy_hal::WIFI_ERROR_OUT_OF_MEMORY:
return "OUT_OF_MEMORY";
case legacy_hal::WIFI_ERROR_BUSY:
return "BUSY";
case legacy_hal::WIFI_ERROR_UNKNOWN:
return "UNKNOWN";
default:
return "UNKNOWN ERROR";
}
}
WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description) {
return {code, description};
}
WifiStatus createWifiStatus(WifiStatusCode code) {
return createWifiStatus(code, "");
}
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error, const std::string& desc) {
switch (error) {
case legacy_hal::WIFI_ERROR_UNINITIALIZED:
case legacy_hal::WIFI_ERROR_NOT_AVAILABLE:
return createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE, desc);
case legacy_hal::WIFI_ERROR_NOT_SUPPORTED:
return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED, desc);
case legacy_hal::WIFI_ERROR_INVALID_ARGS:
case legacy_hal::WIFI_ERROR_INVALID_REQUEST_ID:
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS, desc);
case legacy_hal::WIFI_ERROR_TIMED_OUT:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, desc + ", timed out");
case legacy_hal::WIFI_ERROR_TOO_MANY_REQUESTS:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, desc + ", too many requests");
case legacy_hal::WIFI_ERROR_OUT_OF_MEMORY:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, desc + ", out of memory");
case legacy_hal::WIFI_ERROR_BUSY:
return createWifiStatus(WifiStatusCode::ERROR_BUSY);
case legacy_hal::WIFI_ERROR_NONE:
return createWifiStatus(WifiStatusCode::SUCCESS, desc);
case legacy_hal::WIFI_ERROR_UNKNOWN:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown");
default:
return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN, "unknown error");
}
}
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error) {
return createWifiStatusFromLegacyError(error, "");
}
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android

44
wifi/1.6/default/wifi_status_util.h
View File

@@ -1,44 +0,0 @@
/*
* 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_STATUS_UTIL_H_
#define WIFI_STATUS_UTIL_H_
#include <android/hardware/wifi/1.4/IWifi.h>
#include "wifi_legacy_hal.h"
namespace android {
namespace hardware {
namespace wifi {
namespace V1_6 {
namespace implementation {
using namespace android::hardware::wifi::V1_0;
std::string legacyErrorToString(legacy_hal::wifi_error error);
WifiStatus createWifiStatus(WifiStatusCode code, const std::string& description);
WifiStatus createWifiStatus(WifiStatusCode code);
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error,
const std::string& description);
WifiStatus createWifiStatusFromLegacyError(legacy_hal::wifi_error error);
} // namespace implementation
} // namespace V1_6
} // namespace wifi
} // namespace hardware
} // namespace android
#endif // WIFI_STATUS_UTIL_H_