Merge "Remove default implementation for PowerHal 1.1" into oc-mr1-dev

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

cc_binary {

    proprietary: true,

    defaults: ["hidl_defaults"],

    relative_install_path: "hw",

    name: "android.hardware.power@1.1-service",

    init_rc: ["android.hardware.power@1.1-service.rc"],

    srcs: ["service.cpp" , "Power.cpp"],

    shared_libs: [

        "liblog",

        "libdl",

        "libutils",

        "libhardware",

        "libhidlbase",

        "libhidltransport",

        "android.hardware.power@1.0",

        "android.hardware.power@1.1",

    ],

}

/*

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

 */

#define LOG_TAG "android.hardware.power@1.1-impl"

#include <log/log.h>

#include <hardware/hardware.h>

#include <hardware/power.h>

#include "Power.h"

namespace android {

namespace hardware {

namespace power {

namespace V1_1 {

namespace implementation {

using ::android::hardware::power::V1_0::Feature;

using ::android::hardware::power::V1_0::PowerHint;

using ::android::hardware::power::V1_0::PowerStatePlatformSleepState;

using ::android::hardware::power::V1_0::Status;

using ::android::hardware::power::V1_1::PowerStateSubsystem;

using ::android::hardware::hidl_vec;

using ::android::hardware::Return;

using ::android::hardware::Void;

Power::Power(power_module_t *module) : mModule(module) {

    if (mModule)

        mModule->init(mModule);

}

Power::~Power() {

    delete(mModule);

}

// Methods from ::android::hardware::power::V1_0::IPower follow.

Return<void> Power::setInteractive(bool interactive)  {

    if (mModule->setInteractive)

        mModule->setInteractive(mModule, interactive ? 1 : 0);

    return Void();

}

Return<void> Power::powerHint(PowerHint hint, int32_t data)  {

    int32_t param = data;

    if (mModule->powerHint) {

        if (data)

            mModule->powerHint(mModule, static_cast<power_hint_t>(hint), &param);

        else

            mModule->powerHint(mModule, static_cast<power_hint_t>(hint), NULL);

    }

    return Void();

}

Return<void> Power::setFeature(Feature feature, bool activate)  {

    if (mModule->setFeature)

        mModule->setFeature(mModule, static_cast<feature_t>(feature),

                activate ? 1 : 0);

    return Void();

}

Return<void> Power::getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb)  {

    hidl_vec<PowerStatePlatformSleepState> states;

    ssize_t number_platform_modes;

    size_t *voters = nullptr;

    power_state_platform_sleep_state_t *legacy_states = nullptr;

    int ret;

    if (mModule->get_number_of_platform_modes == nullptr ||

            mModule->get_voter_list == nullptr ||

            mModule->get_platform_low_power_stats == nullptr)

    {

        _hidl_cb(states, Status::SUCCESS);

        return Void();

    }

    number_platform_modes = mModule->get_number_of_platform_modes(mModule);

    if (number_platform_modes)

    {

       if ((ssize_t) (SIZE_MAX / sizeof(size_t)) <= number_platform_modes)  // overflow

           goto done;

       voters = new (std::nothrow) size_t [number_platform_modes];

       if (voters == nullptr)

           goto done;

       ret = mModule->get_voter_list(mModule, voters);

       if (ret != 0)

           goto done;

       if ((ssize_t) (SIZE_MAX / sizeof(power_state_platform_sleep_state_t))

           <= number_platform_modes)  // overflow

           goto done;

       legacy_states = new (std::nothrow)

           power_state_platform_sleep_state_t [number_platform_modes];

       if (legacy_states == nullptr)

           goto done;

       for (int i = 0; i < number_platform_modes; i++)

       {

          legacy_states[i].voters = nullptr;

          legacy_states[i].voters = new power_state_voter_t [voters[i]];

          if (legacy_states[i].voters == nullptr)

              goto done;

       }

       ret = mModule->get_platform_low_power_stats(mModule, legacy_states);

       if (ret != 0)

           goto done;

       states.resize(number_platform_modes);

       for (int i = 0; i < number_platform_modes; i++)

       {

          power_state_platform_sleep_state_t& legacy_state = legacy_states[i];

          PowerStatePlatformSleepState& state = states[i];

          state.name = legacy_state.name;

          state.residencyInMsecSinceBoot = legacy_state.residency_in_msec_since_boot;

          state.totalTransitions = legacy_state.total_transitions;

          state.supportedOnlyInSuspend = legacy_state.supported_only_in_suspend;

          state.voters.resize(voters[i]);

          for(size_t j = 0; j < voters[i]; j++)

          {

              state.voters[j].name = legacy_state.voters[j].name;

              state.voters[j].totalTimeInMsecVotedForSinceBoot = legacy_state.voters[j].total_time_in_msec_voted_for_since_boot;

              state.voters[j].totalNumberOfTimesVotedSinceBoot = legacy_state.voters[j].total_number_of_times_voted_since_boot;

          }

       }

    }

done:

    if (legacy_states)

    {

        for (int i = 0; i < number_platform_modes; i++)

        {

            if(legacy_states[i].voters)

                delete(legacy_states[i].voters);

        }

    }

    delete[] legacy_states;

    delete[] voters;

    _hidl_cb(states, Status::SUCCESS);

    return Void();

}

// Methods from ::android::hardware::power::V1_1::IPower follow.

Return<void> Power::getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) {

    hidl_vec<PowerStateSubsystem> subsystems;

    ssize_t number_subsystems = 0;

    //This API will report zero subsystems to support older devices

    //For devices that support this API, they will have their own implementation

    subsystems.resize(number_subsystems);

    _hidl_cb(subsystems, Status::SUCCESS);

    return Void();

}

Return<void> Power::powerHintAsync(PowerHint hint, int32_t data) {

    // just call the normal power hint in this oneway function

    return powerHint(hint, data);

}

} // namespace implementation

}  // namespace V1_1

}  // namespace power

}  // 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 ANDROID_HARDWARE_POWER_V1_1_POWER_H

#define ANDROID_HARDWARE_POWER_V1_1_POWER_H

#include <android/hardware/power/1.1/IPower.h>

#include <hidl/MQDescriptor.h>

#include <hidl/Status.h>

#include <hardware/power.h>

namespace android {

namespace hardware {

namespace power {

namespace V1_1 {

namespace implementation {

using ::android::hardware::power::V1_0::Feature;

using ::android::hardware::power::V1_0::PowerHint;

using ::android::hardware::power::V1_1::IPower;

using ::android::hardware::Return;

using ::android::hardware::Void;

struct Power : public IPower {

    Power(power_module_t* module);

    ~Power();

    // Methods from ::android::hardware::power::V1_0::IPower follow

    Return<void> setInteractive(bool interactive) override;

    Return<void> powerHint(PowerHint hint, int32_t data) override;

    Return<void> setFeature(Feature feature, bool activate) override;

    Return<void> getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb) override;

    // Methods from ::android::hardware::power::V1_1::IPower follow.

    Return<void> getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) override;

    Return<void> powerHintAsync(PowerHint hint, int32_t data) override;

    // Methods from ::android::hidl::base::V1_0::IBase follow.

  private:

    power_module_t* mModule;

};

}  // namespace implementation

}  // namespace V1_1

}  // namespace power

}  // namespace hardware

}  // namespace android

#endif  // ANDROID_HARDWARE_POWER_V1_1_POWER_H

service power-hal-1-1 /vendor/bin/hw/android.hardware.power@1.1-service

    class hal

    user system

    group system

/*

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

 */

#define LOG_TAG "android.hardware.power@1.1-service"

#include <android/log.h>

#include <hidl/HidlTransportSupport.h>

#include <android/hardware/power/1.1/IPower.h>

#include <hardware/power.h>

#include "Power.h"

using android::sp;

using android::status_t;

using android::OK;

// libhwbinder:

using android::hardware::configureRpcThreadpool;

using android::hardware::joinRpcThreadpool;

// Generated HIDL files

using android::hardware::power::V1_1::IPower;

using android::hardware::power::V1_1::implementation::Power;

int main() {

    status_t status;

    android::sp<IPower> service = nullptr;

    const hw_module_t* hw_module = nullptr;

    power_module_t* power_module = nullptr;

    int err;

    ALOGI("Power HAL Service 1.1 (Default) is starting.");

    err = hw_get_module(POWER_HARDWARE_MODULE_ID, &hw_module);

    if (err) {

        ALOGE("hw_get_module %s failed: %d", POWER_HARDWARE_MODULE_ID, err);

        goto shutdown;

    }

    if (!hw_module->methods || !hw_module->methods->open) {

        power_module = reinterpret_cast<power_module_t*>(

            const_cast<hw_module_t*>(hw_module));

    } else {

        err = hw_module->methods->open(hw_module, POWER_HARDWARE_MODULE_ID,

                                           reinterpret_cast<hw_device_t**>(&power_module));

        if (err) {

            ALOGE("Passthrough failed to load legacy HAL.");

            goto shutdown;

        }

    }

    service = new Power(power_module);

    if (service == nullptr) {

        ALOGE("Can not create an instance of Power HAL Iface, exiting.");

        goto shutdown;

    }

    configureRpcThreadpool(1, true /*callerWillJoin*/);

    status = service->registerAsService();

    if (status != OK) {

        ALOGE("Could not register service for Power HAL Iface (%d).", status);

        goto shutdown;

    }

    ALOGI("Power Service is ready");

    joinRpcThreadpool();

    //Should not pass this line

shutdown:

    // In normal operation, we don't expect the thread pool to exit

    ALOGE("Power Service is shutting down");

    return 1;

}