/******************************************************************************
 *
 * 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.
 *
 *****************************************************************************/
// TODO(rsakthi) - how to get this from bazel?
#define CPTCFG_IWLMVM 1

#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;
}