wifi: Move legacy HAL implementation

# 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.

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := android.hardware.wifi@1.0-impl

LOCAL_MODULE_RELATIVE_PATH := hw

LOCAL_CPPFLAGS := -std=c++11 -Wall -Wno-unused-parameter -Werror -Wextra

LOCAL_SRC_FILES := \

    failure_reason_util.cpp \

    wifi_chip.cpp \

    wifi.cpp \

    wifi_hal_state.cpp

LOCAL_SHARED_LIBRARIES := \

    android.hardware.wifi@1.0 \

    libbase \

    libcutils \

    libhidl \

    libhwbinder \

    liblog \

    libnl \

    libutils

LOCAL_WHOLE_STATIC_LIBRARIES := $(LIB_WIFI_HAL)

include $(BUILD_SHARED_LIBRARY)

include $(CLEAR_VARS)

LOCAL_MODULE := android.hardware.wifi@1.0-service

LOCAL_MODULE_RELATIVE_PATH := hw

LOCAL_CPPFLAGS := -std=c++11 -Wall -Wno-unused-parameter -Werror -Wextra

LOCAL_SRC_FILES := \

    service.cpp

LOCAL_SHARED_LIBRARIES := \

    android.hardware.wifi@1.0 \

    android.hardware.wifi@1.0-impl \

    libbase \

    libcutils \

    libhidl \

    libhwbinder \

    liblog \

    libnl \

    libutils

LOCAL_WHOLE_STATIC_LIBRARIES := $(LIB_WIFI_HAL)

LOCAL_INIT_RC := android.hardware.wifi@1.0-service.rc

include $(BUILD_EXECUTABLE)

service wifi_hal_legacy /system/bin/hw/android.hardware.wifi@1.0-service

    class hal

    user wifi

    group wifi

/*

 * 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 "failure_reason_util.h"

using ::android::hardware::wifi::V1_0::CommandFailureReason;

namespace android {

namespace hardware {

namespace wifi {

std::string LegacyErrorToString(wifi_error error) {

  switch(error) {

    case WIFI_SUCCESS:

      return "SUCCESS";

    case WIFI_ERROR_UNINITIALIZED:

      return "UNINITIALIZED";

    case WIFI_ERROR_NOT_AVAILABLE:

      return "NOT_AVAILABLE";

    case WIFI_ERROR_NOT_SUPPORTED:

      return "NOT_SUPPORTED";

    case WIFI_ERROR_INVALID_ARGS:

      return "INVALID_ARGS";

    case WIFI_ERROR_INVALID_REQUEST_ID:

      return "INVALID_REQUEST_ID";

    case WIFI_ERROR_TIMED_OUT:

      return "TIMED_OUT";

    case WIFI_ERROR_TOO_MANY_REQUESTS:

      return "TOO_MANY_REQUESTS";

    case WIFI_ERROR_OUT_OF_MEMORY:

      return "OUT_OF_MEMORY";

    case WIFI_ERROR_UNKNOWN:

    default:

      return "UNKNOWN";

  }

}

V1_0::FailureReason CreateFailureReason(

    CommandFailureReason reason, const std::string& description) {

  V1_0::FailureReason result;

  result.reason = reason;

  result.description = description.data();

  return result;

}

V1_0::FailureReason CreateFailureReasonLegacyError(

    wifi_error error, const std::string& desc) {

  switch(error) {

    case WIFI_ERROR_UNINITIALIZED:

    case WIFI_ERROR_NOT_AVAILABLE:

      return CreateFailureReason(CommandFailureReason::NOT_AVAILABLE, desc);

    case WIFI_ERROR_NOT_SUPPORTED:

      return CreateFailureReason(CommandFailureReason::NOT_SUPPORTED, desc);

    case WIFI_ERROR_INVALID_ARGS:

    case WIFI_ERROR_INVALID_REQUEST_ID:

      return CreateFailureReason(CommandFailureReason::INVALID_ARGS, desc);

    case WIFI_ERROR_TIMED_OUT:

      return CreateFailureReason(

          CommandFailureReason::UNKNOWN, desc + ", timed out");

    case WIFI_ERROR_TOO_MANY_REQUESTS:

      return CreateFailureReason(

          CommandFailureReason::UNKNOWN, desc + ", too many requests");

    case WIFI_ERROR_OUT_OF_MEMORY:

      return CreateFailureReason(

          CommandFailureReason::UNKNOWN, desc + ", out of memory");

    case WIFI_ERROR_NONE:

    case WIFI_ERROR_UNKNOWN:

    default:

      return CreateFailureReason(CommandFailureReason::UNKNOWN, "unknown");

  }

}

}  // namespace wifi

}  // namespace hardware

}  // namespace android

/*

 * 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 FAILURE_REASON_UTIL_H_

#define FAILURE_REASON_UTIL_H_

#include <android/hardware/wifi/1.0/IWifi.h>

#include <hardware_legacy/wifi_hal.h>

namespace android {

namespace hardware {

namespace wifi {

std::string LegacyErrorToString(wifi_error error);

V1_0::FailureReason CreateFailureReason(

    V1_0::CommandFailureReason reason, const std::string& description);

V1_0::FailureReason CreateFailureReasonLegacyError(

    wifi_error error, const std::string& description);

}  // namespace wifi

}  // namespace hardware

}  // namespace android

#endif  // FAILURE_REASON_UTIL_H_

/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <android-base/logging.h>

#include <hidl/IServiceManager.h>

#include <hwbinder/IPCThreadState.h>

#include <hwbinder/ProcessState.h>

#include <utils/Looper.h>

#include <utils/StrongPointer.h>

#include "wifi.h"

using android::hardware::hidl_version;

using android::hardware::IPCThreadState;

using android::hardware::ProcessState;

using android::Looper;

namespace {

int OnBinderReadReady(int /*fd*/, int /*events*/, void* /*data*/) {

  IPCThreadState::self()->handlePolledCommands();

  return 1;  // continue receiving events

}

}

int main(int /*argc*/, char** argv) {

  android::base::InitLogging(

      argv, android::base::LogdLogger(android::base::SYSTEM));

  LOG(INFO) << "wifi_hal_legacy is starting up...";

  // Setup binder

  int binder_fd = -1;

  ProcessState::self()->setThreadPoolMaxThreadCount(0);

  CHECK_EQ(IPCThreadState::self()->setupPolling(&binder_fd),

           android::NO_ERROR) << "Failed to initialize binder polling";

  CHECK_GE(binder_fd, 0) << "Invalid binder FD: " << binder_fd;

  // Setup looper

  android::sp<Looper> looper = Looper::prepare(0 /* no options */);

  CHECK(looper->addFd(

      binder_fd, 0, Looper::EVENT_INPUT, OnBinderReadReady, nullptr))

      << "Failed to watch binder FD";

  // Setup hwbinder service

  android::sp<android::hardware::wifi::Wifi> service =

      new android::hardware::wifi::Wifi(looper);

  CHECK_EQ(service->registerAsService("wifi"),

           android::NO_ERROR) << "Failed to register wifi HAL";

  // Loop

  while (looper->pollAll(-1) != Looper::POLL_ERROR);

  LOG(INFO) << "wifi_hal_legacy is terminating...";

  return 0;

}