/******************************************************************************
 *
 * Copyright(c) 2017        Intel Deutschland GmbH
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Intel Corporation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *****************************************************************************/

#include "acpi.h"
#include "iwl-debug.h"
#include "iwl-drv.h"

void* iwl_acpi_get_object(struct device* dev, acpi_string method) {
    acpi_handle root_handle;
    acpi_handle handle;
    struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
    acpi_status status;

    root_handle = ACPI_HANDLE(dev);
    if (!root_handle) {
        IWL_DEBUG_DEV_RADIO(dev, "Could not retrieve root port ACPI handle\n");
        return ERR_PTR(-ENOENT);
    }

    /* Get the method's handle */
    status = acpi_get_handle(root_handle, method, &handle);
    if (ACPI_FAILURE(status)) {
        IWL_DEBUG_DEV_RADIO(dev, "%s method not found\n", method);
        return ERR_PTR(-ENOENT);
    }

    /* Call the method with no arguments */
    status = acpi_evaluate_object(handle, NULL, NULL, &buf);
    if (ACPI_FAILURE(status)) {
        IWL_DEBUG_DEV_RADIO(dev, "%s invocation failed (0x%x)\n", method, status);
        return ERR_PTR(-ENOENT);
    }

    return buf.pointer;
}
IWL_EXPORT_SYMBOL(iwl_acpi_get_object);

union acpi_object* iwl_acpi_get_wifi_pkg(struct device* dev, union acpi_object* data,
                                         int data_size) {
    int i;
    union acpi_object* wifi_pkg;

    /*
     * We need at least one entry in the wifi package that
     * describes the domain, and one more entry, otherwise there's
     * no point in reading it.
     */
    if (WARN_ON_ONCE(data_size < 2)) { return ERR_PTR(-EINVAL); }

    /*
     * We need at least two packages, one for the revision and one
     * for the data itself.  Also check that the revision is valid
     * (i.e. it is an integer set to 0).
     */
    if (data->type != ACPI_TYPE_PACKAGE || data->package.count < 2 ||
        data->package.elements[0].type != ACPI_TYPE_INTEGER ||
        data->package.elements[0].integer.value != 0) {
        IWL_DEBUG_DEV_RADIO(dev, "Unsupported packages structure\n");
        return ERR_PTR(-EINVAL);
    }

    /* loop through all the packages to find the one for WiFi */
    for (i = 1; i < data->package.count; i++) {
        union acpi_object* domain;

        wifi_pkg = &data->package.elements[i];

        /* skip entries that are not a package with the right size */
        if (wifi_pkg->type != ACPI_TYPE_PACKAGE || wifi_pkg->package.count != data_size) {
            continue;
        }

        domain = &wifi_pkg->package.elements[0];
        if (domain->type == ACPI_TYPE_INTEGER && domain->integer.value == ACPI_WIFI_DOMAIN) {
            goto found;
        }
    }

    return ERR_PTR(-ENOENT);

found:
    return wifi_pkg;
}
IWL_EXPORT_SYMBOL(iwl_acpi_get_wifi_pkg);

int iwl_acpi_get_mcc(struct device* dev, char* mcc) {
    union acpi_object *wifi_pkg, *data;
    uint32_t mcc_val;
    int ret;

    data = iwl_acpi_get_object(dev, ACPI_WRDD_METHOD);
    if (IS_ERR(data)) { return PTR_ERR(data); }

    wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data, ACPI_WRDD_WIFI_DATA_SIZE);
    if (IS_ERR(wifi_pkg)) {
        ret = PTR_ERR(wifi_pkg);
        goto out_free;
    }

    if (wifi_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
        ret = -EINVAL;
        goto out_free;
    }

    mcc_val = wifi_pkg->package.elements[1].integer.value;

    mcc[0] = (mcc_val >> 8) & 0xff;
    mcc[1] = mcc_val & 0xff;
    mcc[2] = '\0';

    ret = 0;
out_free:
    kfree(data);
    return ret;
}
IWL_EXPORT_SYMBOL(iwl_acpi_get_mcc);

uint64_t iwl_acpi_get_pwr_limit(struct device* dev) {
    union acpi_object *data, *wifi_pkg;
    uint64_t dflt_pwr_limit;

    data = iwl_acpi_get_object(dev, ACPI_SPLC_METHOD);
    if (IS_ERR(data)) {
        dflt_pwr_limit = 0;
        goto out;
    }

    wifi_pkg = iwl_acpi_get_wifi_pkg(dev, data, ACPI_SPLC_WIFI_DATA_SIZE);
    if (IS_ERR(wifi_pkg) || wifi_pkg->package.elements[1].integer.value != ACPI_TYPE_INTEGER) {
        dflt_pwr_limit = 0;
        goto out_free;
    }

    dflt_pwr_limit = wifi_pkg->package.elements[1].integer.value;
out_free:
    kfree(data);
out:
    return dflt_pwr_limit;
}
IWL_EXPORT_SYMBOL(iwl_acpi_get_pwr_limit);