/******************************************************************************
 *
 * Copyright(c) 2013 - 2015 Intel Corporation. All rights reserved.
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
 * Copyright(c) 2016        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 "iwl-dbg-cfg.h"
#include <linux/export.h>
#include <linux/firmware.h>
#include <linux/slab.h>
#include <linux/types.h>
#include "iwl-modparams.h"

/* grab default values */
#undef CPTCFG_IWLWIFI_SUPPORT_DEBUG_OVERRIDES
#include "iwl-constants.h"
#if IS_ENABLED(CPTCFG_IWLXVT)
#include "xvt/constants.h"
#endif
#if IS_ENABLED(CPTCFG_IWLMVM)
#include "mvm/constants.h"
#endif

struct iwl_dbg_cfg current_dbg_config = {
#define DBG_CFG_REINCLUDE
#define IWL_DBG_CFG(type, name) .name = IWL_##name,
#define IWL_DBG_CFG_STR(name)         /* no default */
#define IWL_DBG_CFG_NODEF(type, name) /* no default */
#define IWL_DBG_CFG_BIN(name)         /* nothing, default empty */
#define IWL_DBG_CFG_BINA(name, max)   /* nothing, default empty */
#define IWL_MOD_PARAM(type, name)     /* nothing, default empty */
#define IWL_MVM_MOD_PARAM(type, name) /* nothing, default empty */
#define IWL_DBG_CFG_RANGE(type, name, min, max) .name = IWL_##name,
#include "iwl-dbg-cfg.h"
#undef IWL_DBG_CFG
#undef IWL_DBG_CFG_STR
#undef IWL_DBG_CFG_NODEF
#undef IWL_DBG_CFG_BIN
#undef IWL_DBG_CFG_BINA
#undef IWL_DBG_CFG_RANGE
#undef IWL_MOD_PARAM
#undef IWL_MVM_MOD_PARAM
};

static const char dbg_cfg_magic[] = "[IWL DEBUG CONFIG DATA]";

#define DBG_CFG_LOADER(_type)                                                                     \
    static void __maybe_unused dbg_cfg_load_##_type(const char* name, const char* val, void* out, \
                                                    s64 min, s64 max) {                           \
        _type r;                                                                                  \
                                                                                                  \
        if (kstrto##_type(val, 0, &r)) {                                                          \
            printk(KERN_INFO "iwlwifi debug config: Invalid data for %s: %s\n", name, val);       \
            return;                                                                               \
        }                                                                                         \
                                                                                                  \
        if (min && max && (r < min || r > max)) {                                                 \
            printk(KERN_INFO "iwlwifi debug config: value %u for %s out of range [%lld,%lld]\n",  \
                   r, name, min, max);                                                            \
            return;                                                                               \
        }                                                                                         \
                                                                                                  \
        *(_type*)out = r;                                                                         \
        printk(KERN_INFO "iwlwifi debug config: %s=%d\n", name, *(_type*)out);                    \
    }

DBG_CFG_LOADER(uint8_t)
DBG_CFG_LOADER(uint16_t)
DBG_CFG_LOADER(uint32_t)
DBG_CFG_LOADER(int)
DBG_CFG_LOADER(uint)

static void __maybe_unused dbg_cfg_load_bool(const char* name, const char* val, void* out, s64 min,
                                             s64 max) {
    uint8_t v;

    if (kstrtou8(val, 0, &v)) {
        printk(KERN_INFO "iwlwifi debug config: Invalid data for %s: %s\n", name, val);
    } else {
        *(bool*)out = v;
        printk(KERN_INFO "iwlwifi debug config: %s=%d\n", name, *(bool*)out);
    }
}

static int __maybe_unused dbg_cfg_load_bin(const char* name, const char* val,
                                           struct iwl_dbg_cfg_bin* out) {
    int len = strlen(val);
    uint8_t* data;

    if (len % 2) { goto error; }
    len /= 2;

    data = kzalloc(len, GFP_KERNEL);
    if (!data) { return -ENOMEM; }
    if (hex2bin(data, val, len)) {
        kfree(data);
        goto error;
    }
    out->data = data;
    out->len = len;
    printk(KERN_INFO "iwlwifi debug config: %d bytes for %s\n", len, name);
    return 0;
error:
    printk(KERN_INFO "iwlwifi debug config: Invalid data for %s\n", name);
    return -EINVAL;
}

static __maybe_unused void dbg_cfg_load_str(const char* name, const char* val, void* out, s64 min,
                                            s64 max) {
    if (strlen(val) == 0) {
        printk(KERN_INFO "iwlwifi debug config: Invalid data for %s\n", name);
    } else {
        *(char**)out = kstrdup(val, GFP_KERNEL);
        printk(KERN_INFO "iwlwifi debug config: %s=%s\n", name, *(char**)out);
    }
}

void iwl_dbg_cfg_free(struct iwl_dbg_cfg* dbgcfg) {
#define IWL_DBG_CFG(t, n) /* nothing */
#define IWL_DBG_CFG_STR(n) kfree(dbgcfg->n);
#define IWL_DBG_CFG_NODEF(t, n) /* nothing */
#define IWL_DBG_CFG_BIN(n)     \
    do {                       \
        kfree(dbgcfg->n.data); \
        dbgcfg->n.data = NULL; \
        dbgcfg->n.len = 0;     \
    } while (0);
#define IWL_DBG_CFG_BINA(n, max)      \
    do {                              \
        int i;                        \
                                      \
        for (i = 0; i < max; i++) {   \
            kfree(dbgcfg->n[i].data); \
            dbgcfg->n[i].data = NULL; \
            dbgcfg->n[i].len = 0;     \
        }                             \
        dbgcfg->n_##n = 0;            \
    } while (0);
#define IWL_DBG_CFG_RANGE(t, n, min, max) /* nothing */
#define IWL_MOD_PARAM(t, n)               /* nothing */
#define IWL_MVM_MOD_PARAM(t, n)           /* nothing */
#include "iwl-dbg-cfg.h"
#undef IWL_DBG_CFG
#undef IWL_DBG_CFG_STR
#undef IWL_DBG_CFG_NODEF
#undef IWL_DBG_CFG_BIN
#undef IWL_DBG_CFG_BINA
#undef IWL_DBG_CFG_RANGE
#undef IWL_MOD_PARAM
#undef IWL_MVM_MOD_PARAM
}

struct iwl_dbg_cfg_loader {
    const char* name;
    s64 min, max;
    void (*loader)(const char* name, const char* val, void* out, s64 min, s64 max);
    uint32_t offset;
};

static const struct iwl_dbg_cfg_loader iwl_dbg_cfg_loaders[] = {
#define IWL_DBG_CFG(t, n)                          \
    {                                              \
        .name = #n,                                \
        .offset = offsetof(struct iwl_dbg_cfg, n), \
        .loader = dbg_cfg_load_##t,                \
    },
#define IWL_DBG_CFG_STR(n)                         \
    {                                              \
        .name = #n,                                \
        .offset = offsetof(struct iwl_dbg_cfg, n), \
        .loader = dbg_cfg_load_str,                \
    },
#define IWL_DBG_CFG_NODEF(t, n) IWL_DBG_CFG(t, n)
#define IWL_DBG_CFG_BIN(n)       /* not using this */
#define IWL_DBG_CFG_BINA(n, max) /* not using this */
#define IWL_DBG_CFG_RANGE(t, n, _min, _max)        \
    {                                              \
        .name = #n,                                \
        .offset = offsetof(struct iwl_dbg_cfg, n), \
        .min = _min,                               \
        .max = _max,                               \
        .loader = dbg_cfg_load_##t,                \
    },
#define IWL_MOD_PARAM(t, n)     /* no using this */
#define IWL_MVM_MOD_PARAM(t, n) /* no using this */
#include "iwl-dbg-cfg.h"
#undef IWL_DBG_CFG
#undef IWL_DBG_CFG_STR
#undef IWL_DBG_CFG_NODEF
#undef IWL_DBG_CFG_BIN
#undef IWL_DBG_CFG_BINA
#undef IWL_DBG_CFG_RANGE
#undef IWL_MOD_PARAM
#undef IWL_MVM_MOD_PARAM
};

void iwl_dbg_cfg_load_ini(struct device* dev, struct iwl_dbg_cfg* dbgcfg) {
    const struct firmware* fw;
    char *data, *end, *pos;
    int err;

    if (dbgcfg->loaded) { return; }

    /* TODO: maybe add a per-device file? */
    err = request_firmware(&fw, "iwl-dbg-cfg.ini", dev);
    if (err) { return; }

    /* must be ini file style with magic section header */
    if (fw->size < strlen(dbg_cfg_magic)) { goto release; }
    if (memcmp(fw->data, dbg_cfg_magic, strlen(dbg_cfg_magic))) {
        printk(KERN_INFO "iwlwifi debug config: file is malformed\n");
        goto release;
    }

    /* +1 guarantees the last line gets NUL-terminated even without \n */
    data = kzalloc(fw->size - strlen(dbg_cfg_magic) + 1, GFP_KERNEL);
    if (!data) { goto release; }
    memcpy(data, fw->data + strlen(dbg_cfg_magic), fw->size - strlen(dbg_cfg_magic));
    end = data + fw->size - strlen(dbg_cfg_magic);
    /* replace CR/LF with NULs to make parsing easier */
    for (pos = data; pos < end; pos++) {
        if (*pos == '\n' || *pos == '\r') { *pos = '\0'; }
    }

    pos = data;
    while (pos < end) {
        const char* line = pos;
        bool loaded = false;
        int idx;

        /* skip to next line */
        while (pos < end && *pos) {
            pos++;
        }
        /* skip to start of next line, over empty ones if any */
        while (pos < end && !*pos) {
            pos++;
        }

        /* skip empty lines and comments */
        if (!*line || *line == '#') { continue; }

        for (idx = 0; idx < ARRAY_SIZE(iwl_dbg_cfg_loaders); idx++) {
            const struct iwl_dbg_cfg_loader* l;

            l = &iwl_dbg_cfg_loaders[idx];

            if (strncmp(l->name, line, strlen(l->name)) == 0 && line[strlen(l->name)] == '=') {
                l->loader(l->name, line + strlen(l->name) + 1,
                          (void*)((uint8_t*)dbgcfg + l->offset), l->min, l->max);
                loaded = true;
            }
        }

        /*
         * if it was loaded by the loaders, don't bother checking
         * more or printing an error message below
         */
        if (loaded) { continue; }

#define IWL_DBG_CFG(t, n)       /* handled above */
#define IWL_DBG_CFG_NODEF(t, n) /* handled above */
#define IWL_DBG_CFG_BIN(n)                                               \
    if (strncmp(#n, line, strlen(#n)) == 0 && line[strlen(#n)] == '=') { \
        dbg_cfg_load_bin(#n, line + strlen(#n) + 1, &dbgcfg->n);         \
        continue;                                                        \
    }
#define IWL_DBG_CFG_BINA(n, max)                                                     \
    if (strncmp(#n, line, strlen(#n)) == 0 && line[strlen(#n)] == '=') {             \
        if (dbgcfg->n_##n >= max) {                                                  \
            printk(KERN_INFO "iwlwifi debug config: " #n " given too many times\n"); \
            continue;                                                                \
        }                                                                            \
        if (!dbg_cfg_load_bin(#n, line + strlen(#n) + 1, &dbgcfg->n[dbgcfg->n_##n])) \
            dbgcfg->n_##n++;                                                         \
        continue;                                                                    \
    }
#define IWL_DBG_CFG_RANGE(t, n, min, max) /* handled above */
#define IWL_DBG_CFG_STR(n)                /* handled above */
#define IWL_MOD_PARAM(t, n)                                                       \
    if (strncmp(#n, line, strlen(#n)) == 0 && line[strlen(#n)] == '=') {          \
        dbg_cfg_load_##t(#n, line + strlen(#n) + 1, &iwlwifi_mod_params.n, 0, 0); \
        continue;                                                                 \
    }
#define IWL_MVM_MOD_PARAM(t, n)                                                                   \
    {                                                                                             \
        if (strncmp("mvm." #n, line, strlen("mvm." #n)) == 0 && line[strlen("mvm." #n)] == '=') { \
            dbg_cfg_load_##t("mvm." #n, line + strlen("mvm." #n) + 1, &dbgcfg->mvm_##n, 0, 0);    \
            dbgcfg->__mvm_mod_param_##n = true;                                                   \
            continue;                                                                             \
        }                                                                                         \
    }
#include "iwl-dbg-cfg.h"
#undef IWL_DBG_CFG
#undef IWL_DBG_CFG_STR
#undef IWL_DBG_CFG_NODEF
#undef IWL_DBG_CFG_BIN
#undef IWL_DBG_CFG_BINA
#undef IWL_DBG_CFG_RANGE
#undef IWL_MOD_PARAM
#undef IWL_MVM_MOD_PARAM
        printk(KERN_INFO "iwlwifi debug config: failed to load line \"%s\"\n", line);
    }

    kfree(data);
release:
    release_firmware(fw);
    dbgcfg->loaded = true;
}