wifi: Move legacy HAL implementation
Changes in the CL:
1. Move the legacy HAL implementation from
"frameworks/opt/net/wifi/wifi_hal_legacy" to
"hardware/interfaces/wifi/1.0/default".
2. Renamed the .rc file and the module name in makefile to
conform to the HIDL style guide.
Files renamed from:
wifi_hal_service.cpp/h -> wifi.cpp/h
wifi_chip_service.cpp/h -> wifi_chip.cpp/h
main.cpp -> service
Bug: 31821133
Test: mmma -j32 hardware/interfaces/wifi/1.0/default
Change-Id: I5e65e2fdb5596346bde6963588031dcea42d633a
diff --git a/wifi/1.0/default/wifi.cpp b/wifi/1.0/default/wifi.cpp
new file mode 100644
index 0000000..0e10bfb
--- /dev/null
+++ b/wifi/1.0/default/wifi.cpp
@@ -0,0 +1,187 @@
+/*
+ * 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.h"
+
+#include <android-base/logging.h>
+#include <cutils/properties.h>
+
+#include "failure_reason_util.h"
+#include "wifi_chip.h"
+
+using ::android::hardware::wifi::V1_0::CommandFailureReason;
+using RunState = ::android::hardware::wifi::WifiHalState::RunState;
+
+namespace {
+std::string GetWlanInterfaceName() {
+ char buffer[PROPERTY_VALUE_MAX];
+ property_get("wifi.interface", buffer, "wlan0");
+ return buffer;
+}
+}
+
+namespace android {
+namespace hardware {
+namespace wifi {
+
+Wifi::Wifi(sp<Looper>& looper) : state_(looper) {
+ CHECK_EQ(init_wifi_vendor_hal_func_table(&state_.func_table_), WIFI_SUCCESS)
+ << "Failed to initialize hal func table";
+}
+
+Return<void> Wifi::registerEventCallback(
+ const sp<V1_0::IWifiEventCallback>& callback) {
+ // TODO(b/31632518): remove the callback when the client is destroyed
+ callbacks_.insert(callback);
+ return Void();
+}
+
+Return<bool> Wifi::isStarted() {
+ return state_.run_state_ != RunState::STOPPED;
+}
+
+Return<void> Wifi::start() {
+ if (state_.run_state_ == RunState::STARTED) {
+ for (auto& callback : callbacks_) {
+ callback->onStart();
+ }
+ return Void();
+ } else if (state_.run_state_ == RunState::STOPPING) {
+ for (auto& callback : callbacks_) {
+ callback->onStartFailure(CreateFailureReason(
+ CommandFailureReason::NOT_AVAILABLE, "HAL is stopping"));
+ }
+ return Void();
+ }
+
+ LOG(INFO) << "Initializing HAL";
+ wifi_error status = state_.func_table_.wifi_initialize(&state_.hal_handle_);
+ if (status != WIFI_SUCCESS) {
+ LOG(ERROR) << "Failed to initialize Wifi HAL";
+ for (auto& callback : callbacks_) {
+ callback->onStartFailure(CreateFailureReasonLegacyError(
+ status, "Failed to initialize HAL"));
+ }
+ return Void();
+ }
+
+ event_loop_thread_ = std::thread(&Wifi::DoHalEventLoop, this);
+
+ wifi_interface_handle iface_handle =
+ FindInterfaceHandle(GetWlanInterfaceName());
+ if (iface_handle != kInterfaceNotFoundHandle) {
+ chip_ = new WifiChip(&state_, iface_handle);
+ } else {
+ // TODO fail to init?
+ }
+
+ state_.run_state_ = RunState::STARTED;
+ for (auto& callback : callbacks_) {
+ callback->onStart();
+ }
+ return Void();
+}
+
+wifi_interface_handle Wifi::FindInterfaceHandle(
+ const std::string& ifname) {
+ int num_iface_handles = 0;
+ wifi_interface_handle* iface_handles = nullptr;
+ wifi_error ret = state_.func_table_.wifi_get_ifaces(
+ state_.hal_handle_, &num_iface_handles, &iface_handles);
+ if (ret != WIFI_SUCCESS) {
+ LOG(ERROR) << "Failed to enumerate interface handles: "
+ << LegacyErrorToString(ret);
+ return kInterfaceNotFoundHandle;
+ }
+
+ char buffer[IFNAMSIZ];
+ for (int i = 0; i < num_iface_handles; ++i) {
+ bzero(buffer, sizeof(buffer));
+ ret = state_.func_table_.wifi_get_iface_name(
+ iface_handles[i], buffer, sizeof(buffer));
+ if (ret != WIFI_SUCCESS) {
+ LOG(WARNING) << "Failed to get interface handle name: "
+ << LegacyErrorToString(ret);
+ continue;
+ }
+ if (ifname == buffer) {
+ return iface_handles[i];
+ }
+ }
+ return kInterfaceNotFoundHandle;
+}
+
+
+void NoopHalCleanupHandler(wifi_handle) {}
+
+Return<void> Wifi::stop() {
+ if (state_.run_state_ == RunState::STOPPED) {
+ for (auto& callback : callbacks_) {
+ callback->onStop();
+ }
+ return Void();
+ } else if (state_.run_state_ == RunState::STOPPING) {
+ return Void();
+ }
+
+ LOG(INFO) << "Cleaning up HAL";
+ awaiting_hal_cleanup_command_ = true;
+ awaiting_hal_event_loop_termination_ = true;
+ state_.run_state_ = RunState::STOPPING;
+
+ if (chip_.get()) chip_->Invalidate();
+ chip_.clear();
+
+ state_.func_table_.wifi_cleanup(state_.hal_handle_, NoopHalCleanupHandler);
+ awaiting_hal_cleanup_command_ = false;
+ LOG(VERBOSE) << "HAL cleanup command complete";
+ FinishHalCleanup();
+ return Void();
+}
+
+void Wifi::DoHalEventLoop() {
+ LOG(VERBOSE) << "Starting HAL event loop";
+ state_.func_table_.wifi_event_loop(state_.hal_handle_);
+ if (state_.run_state_ != RunState::STOPPING) {
+ LOG(FATAL) << "HAL event loop terminated, but HAL was not stopping";
+ }
+ LOG(VERBOSE) << "HAL Event loop terminated";
+ event_loop_thread_.detach();
+ state_.PostTask([this](){
+ awaiting_hal_event_loop_termination_ = false;
+ FinishHalCleanup();
+ });
+}
+
+void Wifi::FinishHalCleanup() {
+ if (!awaiting_hal_cleanup_command_ && !awaiting_hal_event_loop_termination_) {
+ state_.run_state_ = RunState::STOPPED;
+ LOG(INFO) << "HAL cleanup complete";
+ for (auto& callback : callbacks_) {
+ callback->onStop();
+ }
+ }
+}
+
+
+Return<void> Wifi::getChip(getChip_cb cb) {
+ cb(chip_);
+ return Void();
+}
+
+} // namespace wifi
+} // namespace hardware
+} // namespace android