/******************************************************************************
 *
 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
 * Copyright (C) 2018 Intel Corporation
 * 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 "debugfs.h"

#include "api/commands.h"
#include "dbg.h"
#ifdef CPTCFG_IWLWIFI_DEBUG_HOST_CMD_ENABLED
#include "api/dhc.h"
#endif
#include "api/rs.h"

#define FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)                        \
  struct dbgfs_##name##_data {                                                  \
    argtype* arg;                                                               \
    bool read_done;                                                             \
    ssize_t rlen;                                                               \
    char rbuf[buflen];                                                          \
  };                                                                            \
  static int _iwl_dbgfs_##name##_open(struct inode* inode, struct file* file) { \
    struct dbgfs_##name##_data* data;                                           \
                                                                                \
    data = kzalloc(sizeof(*data), GFP_KERNEL);                                  \
    if (!data)                                                                  \
      return -ENOMEM;                                                           \
                                                                                \
    data->read_done = false;                                                    \
    data->arg = inode->i_private;                                               \
    file->private_data = data;                                                  \
                                                                                \
    return 0;                                                                   \
  }

#define FWRT_DEBUGFS_READ_WRAPPER(name)                                                           \
  static ssize_t _iwl_dbgfs_##name##_read(struct file* file, char __user* user_buf, size_t count, \
                                          loff_t* ppos) {                                         \
    struct dbgfs_##name##_data* data = file->private_data;                                        \
                                                                                                  \
    if (!data->read_done) {                                                                       \
      data->read_done = true;                                                                     \
      data->rlen = iwl_dbgfs_##name##_read(data->arg, sizeof(data->rbuf), data->rbuf);            \
    }                                                                                             \
                                                                                                  \
    if (data->rlen < 0)                                                                           \
      return data->rlen;                                                                          \
    return simple_read_from_buffer(user_buf, count, ppos, data->rbuf, data->rlen);                \
  }

static int _iwl_dbgfs_release(struct inode* inode, struct file* file) {
  kfree(file->private_data);

  return 0;
}

#define _FWRT_DEBUGFS_READ_FILE_OPS(name, buflen, argtype)       \
  FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)               \
  FWRT_DEBUGFS_READ_WRAPPER(name)                                \
  static const struct file_operations iwl_dbgfs_##name##_ops = { \
      .read = _iwl_dbgfs_##name##_read,                          \
      .open = _iwl_dbgfs_##name##_open,                          \
      .llseek = generic_file_llseek,                             \
      .release = _iwl_dbgfs_release,                             \
  }

#define FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)                                  \
  static ssize_t _iwl_dbgfs_##name##_write(struct file* file, const char __user* user_buf, \
                                           size_t count, loff_t* ppos) {                   \
    argtype* arg = ((struct dbgfs_##name##_data*)file->private_data)->arg;                 \
    char buf[buflen] = {};                                                                 \
    size_t buf_size = min(count, sizeof(buf) - 1);                                         \
                                                                                           \
    if (copy_from_user(buf, user_buf, buf_size))                                           \
      return -EFAULT;                                                                      \
                                                                                           \
    return iwl_dbgfs_##name##_write(arg, buf, buf_size);                                   \
  }

#define _FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, buflen, argtype) \
  FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)               \
  FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)              \
  FWRT_DEBUGFS_READ_WRAPPER(name)                                \
  static const struct file_operations iwl_dbgfs_##name##_ops = { \
      .write = _iwl_dbgfs_##name##_write,                        \
      .read = _iwl_dbgfs_##name##_read,                          \
      .open = _iwl_dbgfs_##name##_open,                          \
      .llseek = generic_file_llseek,                             \
      .release = _iwl_dbgfs_release,                             \
  }

#define _FWRT_DEBUGFS_WRITE_FILE_OPS(name, buflen, argtype)      \
  FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)               \
  FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)              \
  static const struct file_operations iwl_dbgfs_##name##_ops = { \
      .write = _iwl_dbgfs_##name##_write,                        \
      .open = _iwl_dbgfs_##name##_open,                          \
      .llseek = generic_file_llseek,                             \
      .release = _iwl_dbgfs_release,                             \
  }

#define FWRT_DEBUGFS_READ_FILE_OPS(name, bufsz) \
  _FWRT_DEBUGFS_READ_FILE_OPS(name, bufsz, struct iwl_fw_runtime)

#define FWRT_DEBUGFS_WRITE_FILE_OPS(name, bufsz) \
  _FWRT_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct iwl_fw_runtime)

#define FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz) \
  _FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct iwl_fw_runtime)

#define FWRT_DEBUGFS_ADD_FILE_ALIAS(alias, name, parent, mode)                    \
  do {                                                                            \
    if (!debugfs_create_file(alias, mode, parent, fwrt, &iwl_dbgfs_##name##_ops)) \
      goto err;                                                                   \
  } while (0)
#define FWRT_DEBUGFS_ADD_FILE(name, parent, mode) \
  FWRT_DEBUGFS_ADD_FILE_ALIAS(#name, name, parent, mode)

static int iwl_fw_send_timestamp_marker_cmd(struct iwl_fw_runtime* fwrt) {
  struct iwl_mvm_marker marker = {
      .dw_len = sizeof(struct iwl_mvm_marker) / 4,
      .marker_id = MARKER_ID_SYNC_CLOCK,

      /* the real timestamp is taken from the ftrace clock
       * this is for finding the match between fw and kernel logs
       */
      .timestamp = cpu_to_le64(fwrt->timestamp.seq++),
  };

  struct iwl_host_cmd hcmd = {
      .id = MARKER_CMD,
      .flags = CMD_ASYNC,
      .data[0] = &marker,
      .len[0] = sizeof(marker),
  };

  return iwl_trans_send_cmd(fwrt->trans, &hcmd);
}

static void iwl_fw_timestamp_marker_wk(struct work_struct* work) {
  int ret;
  struct iwl_fw_runtime* fwrt = container_of(work, struct iwl_fw_runtime, timestamp.wk.work);
  unsigned long delay = fwrt->timestamp.delay;

  ret = iwl_fw_send_timestamp_marker_cmd(fwrt);
  if (!ret && delay) {
    schedule_delayed_work(&fwrt->timestamp.wk, round_jiffies_relative(delay));
  } else
    IWL_INFO(fwrt, "stopping timestamp_marker, ret: %d, delay: %u\n", ret,
             jiffies_to_msecs(delay) / 1000);
}

void iwl_fw_trigger_timestamp(struct iwl_fw_runtime* fwrt, uint32_t delay) {
  IWL_INFO(fwrt, "starting timestamp_marker trigger with delay: %us\n", delay);

  iwl_fw_cancel_timestamp(fwrt);

  fwrt->timestamp.delay = msecs_to_jiffies(delay * 1000);

  schedule_delayed_work(&fwrt->timestamp.wk, round_jiffies_relative(fwrt->timestamp.delay));
}

static ssize_t iwl_dbgfs_timestamp_marker_write(struct iwl_fw_runtime* fwrt, char* buf,
                                                size_t count) {
  int ret;
  uint32_t delay;

  ret = kstrtou32(buf, 10, &delay);
  if (ret < 0) {
    return ret;
  }

  iwl_fw_trigger_timestamp(fwrt, delay);

  return count;
}

static ssize_t iwl_dbgfs_timestamp_marker_read(struct iwl_fw_runtime* fwrt, size_t size,
                                               char* buf) {
  uint32_t delay_secs = jiffies_to_msecs(fwrt->timestamp.delay) / 1000;

  return scnprintf(buf, size, "%d\n", delay_secs);
}

FWRT_DEBUGFS_READ_WRITE_FILE_OPS(timestamp_marker, 16);

struct hcmd_write_data {
  __be32 cmd_id;
  __be32 flags;
  __be16 length;
  uint8_t data[0];
} __packed;

static ssize_t iwl_dbgfs_send_hcmd_write(struct iwl_fw_runtime* fwrt, char* buf, size_t count) {
  size_t header_size = (sizeof(uint32_t) * 2 + sizeof(uint16_t)) * 2;
  size_t data_size = (count - 1) / 2;
  int ret;
  struct hcmd_write_data* data;
  struct iwl_host_cmd hcmd = {
      .len =
          {
              0,
          },
      .data =
          {
              NULL,
          },
  };

  if (fwrt->ops && fwrt->ops->fw_running && !fwrt->ops->fw_running(fwrt->ops_ctx)) {
    return -EIO;
  }

  if (count < header_size + 1 || count > 1024 * 4) {
    return -EINVAL;
  }

  data = kmalloc(data_size, GFP_KERNEL);
  if (!data) {
    return -ENOMEM;
  }

  ret = hex2bin((uint8_t*)data, buf, data_size);
  if (ret) {
    goto out;
  }

  hcmd.id = be32_to_cpu(data->cmd_id);
  hcmd.flags = be32_to_cpu(data->flags);
  hcmd.len[0] = be16_to_cpu(data->length);
  hcmd.data[0] = data->data;

  if (count != header_size + hcmd.len[0] * 2 + 1) {
    IWL_ERR(fwrt, "host command data size does not match header length\n");
    ret = -EINVAL;
    goto out;
  }

  if (fwrt->ops && fwrt->ops->send_hcmd) {
    ret = fwrt->ops->send_hcmd(fwrt->ops_ctx, &hcmd);
  } else {
    ret = -EPERM;
  }

  if (ret < 0) {
    goto out;
  }

  if (hcmd.flags & CMD_WANT_SKB) {
    iwl_free_resp(&hcmd);
  }
out:
  kfree(data);
  return ret ?: count;
}

FWRT_DEBUGFS_WRITE_FILE_OPS(send_hcmd, 512);

#ifdef CPTCFG_IWLWIFI_DEBUG_HOST_CMD_ENABLED
struct iwl_dhc_write_data {
  __be32 length;
  __be32 index_and_mask;
  __be32 data[0];
} __packed;

static ssize_t iwl_dbgfs_send_dhc_write(struct iwl_fw_runtime* fwrt, char* buf, size_t count) {
  int ret, i;
  struct iwl_dhc_write_data* data;
  uint32_t length;
  size_t header_size = sizeof(uint32_t) * 2 * 2;
  size_t data_size = (count - 1) / 2, cmd_size;
  struct iwl_dhc_cmd* dhc_cmd = NULL;
  struct iwl_host_cmd hcmd = {
      .id = iwl_cmd_id(DEBUG_HOST_COMMAND, LEGACY_GROUP, 0),
      .flags = CMD_ASYNC,
      .len =
          {
              0,
          },
      .data =
          {
              NULL,
          },
  };

  if (fwrt->ops && fwrt->ops->fw_running && !fwrt->ops->fw_running(fwrt->ops_ctx)) {
    return -EIO;
  }

  if (count < header_size + 1 || count > 1024 * 4) {
    return -EINVAL;
  }

  data = kmalloc(data_size, GFP_KERNEL);
  if (!data) {
    return -ENOMEM;
  }

  ret = hex2bin((uint8_t*)data, buf, data_size);
  if (ret) {
    goto out;
  }

  length = be32_to_cpu(data->length);

  if (count != header_size + sizeof(uint32_t) * length * 2 + 1) {
    IWL_ERR(fwrt, "DHC data size does not match length header\n");
    ret = -EINVAL;
    goto out;
  }

  cmd_size = sizeof(*dhc_cmd) + length * sizeof(uint32_t);
  dhc_cmd = kzalloc(cmd_size, GFP_KERNEL);
  if (!dhc_cmd) {
    ret = -ENOMEM;
    goto out;
  }

  dhc_cmd->length = cpu_to_le32(length);
  dhc_cmd->index_and_mask = cpu_to_le32(be32_to_cpu(data->index_and_mask));
  for (i = 0; i < length; i++) {
    dhc_cmd->data[i] = cpu_to_le32(be32_to_cpu(data->data[i]));
  }

  hcmd.len[0] = cmd_size;
  hcmd.data[0] = dhc_cmd;

  if (fwrt->ops && fwrt->ops->send_hcmd) {
    ret = fwrt->ops->send_hcmd(fwrt->ops_ctx, &hcmd);
  } else {
    ret = -EPERM;
  }
out:
  kfree(dhc_cmd);
  kfree(data);
  return ret ?: count;
}

FWRT_DEBUGFS_WRITE_FILE_OPS(send_dhc, 512);

struct iwl_dhc_tlc_whole_cmd {
  struct iwl_dhc_cmd dhc;
  struct iwl_dhc_tlc_cmd tlc_data;
} __packed;

static void iwl_fw_build_dhc_tlc_cmd(struct iwl_dhc_tlc_whole_cmd* cmd,
                                     enum iwl_tlc_debug_flags flag, uint32_t data) {
  cmd->dhc.length = cpu_to_le32(sizeof(cmd->tlc_data) >> 2);
  cmd->dhc.index_and_mask =
      cpu_to_le32(DHC_TABLE_INTEGRATION | DHC_TARGET_UMAC | DHC_INTEGRATION_TLC_DEBUG_CONFIG);

  cmd->tlc_data.flags = cpu_to_le32(BIT(flag));
  cmd->tlc_data.data[flag] = cpu_to_le32(data);
}

static ssize_t iwl_dbgfs_tpc_enable_write(struct iwl_fw_runtime* fwrt, char* buf, size_t count) {
  struct iwl_dhc_tlc_whole_cmd dhc_cmd = {{0}};
  struct iwl_host_cmd hcmd = {
      .id = iwl_cmd_id(DEBUG_HOST_COMMAND, IWL_ALWAYS_LONG_GROUP, 0),
      .data[0] = &dhc_cmd,
      .len[0] = sizeof(dhc_cmd),
  };
  bool enabled;
  int ret;

  ret = kstrtobool(buf, &enabled);
  iwl_fw_build_dhc_tlc_cmd(&dhc_cmd, IWL_TLC_DEBUG_TPC_ENABLED, enabled);

  ret = iwl_trans_send_cmd(fwrt->trans, &hcmd);
  if (ret) {
    IWL_ERR(fwrt, "Failed to send TLC Debug command: %d\n", ret);
    return ret;
  }

  fwrt->tpc_enabled = enabled;

  return count;
}

static ssize_t iwl_dbgfs_tpc_enable_read(struct iwl_fw_runtime* fwrt, size_t size, char* buf) {
  return scnprintf(buf, size, "tpc is currently %s\n", fwrt->tpc_enabled ? "enabled" : "disabled");
}

FWRT_DEBUGFS_READ_WRITE_FILE_OPS(tpc_enable, 30);

static ssize_t iwl_dbgfs_tpc_stats_read(struct iwl_fw_runtime* fwrt, size_t size, char* buf) {
  struct iwl_dhc_tlc_whole_cmd dhc_cmd = {{0}};
  struct iwl_host_cmd hcmd = {
      .id = iwl_cmd_id(DEBUG_HOST_COMMAND, IWL_ALWAYS_LONG_GROUP, 0),
      .flags = CMD_WANT_SKB,
      .data[0] = &dhc_cmd,
      .len[0] = sizeof(dhc_cmd),
  };
  struct iwl_dhc_cmd_resp* resp;
  struct iwl_tpc_stats* stats;
  int ret = 0;

  iwl_fw_build_dhc_tlc_cmd(&dhc_cmd, IWL_TLC_DEBUG_TPC_STATS, 0);

  ret = iwl_trans_send_cmd(fwrt->trans, &hcmd);
  if (ret) {
    IWL_ERR(fwrt, "Failed to send TLC Debug command: %d\n", ret);
    goto err;
  }

  if (!hcmd.resp_pkt) {
    IWL_ERR(fwrt, "Response expected\n");
    goto err;
  }

  if (iwl_rx_packet_payload_len(hcmd.resp_pkt) != sizeof(*resp) + sizeof(*stats)) {
    IWL_ERR(fwrt, "Invalid size for TPC stats request response (%u instead of %lu)\n",
            iwl_rx_packet_payload_len(hcmd.resp_pkt), sizeof(*resp) + sizeof(*stats));
    ret = -EINVAL;
    goto err;
  }

  resp = (struct iwl_dhc_cmd_resp*)hcmd.resp_pkt->data;
  if (le32_to_cpu(resp->status) != 1) {
    IWL_ERR(fwrt, "response status is not success: %d\n", resp->status);
    ret = -EINVAL;
    goto err;
  }

  stats = (struct iwl_tpc_stats*)resp->data;

  return scnprintf(
      buf, size, "tpc stats: no-tpc %u, step1 %u, step2 %u, step3 %u, step4 %u, step5 %u\n",
      le32_to_cpu(stats->no_tpc), le32_to_cpu(stats->step[0]), le32_to_cpu(stats->step[1]),
      le32_to_cpu(stats->step[2]), le32_to_cpu(stats->step[3]), le32_to_cpu(stats->step[4]));

err:
  return ret ?: -EIO;
}

FWRT_DEBUGFS_READ_FILE_OPS(tpc_stats, 150);

static ssize_t iwl_dbgfs_ps_report_read(struct iwl_fw_runtime* fwrt, size_t size, char* buf,
                                        int mac_mask) {
  __le32 cmd_data;

  struct iwl_dhc_cmd cmd = {
      .length = cpu_to_le32(1),
      .index_and_mask =
          cpu_to_le32(DHC_TABLE_AUTOMATION | mac_mask | DHC_AUTO_UMAC_REPORT_POWER_STATISTICS),
  };

  struct iwl_host_cmd hcmd = {
      .id = iwl_cmd_id(DEBUG_HOST_COMMAND, LEGACY_GROUP, 0),
      .flags = CMD_WANT_SKB,
      .data = {&cmd, &cmd_data},
      .len = {sizeof(cmd), sizeof(cmd_data)},
  };
  struct iwl_dhc_cmd_resp* resp;
  struct iwl_ps_report* report;
  int ret = 0;

  ret = iwl_trans_send_cmd(fwrt->trans, &hcmd);
  if (ret) {
    IWL_ERR(fwrt, "Failed to send power-save report command: %d\n", ret);
    goto err;
  }

  if (!hcmd.resp_pkt) {
    IWL_ERR(fwrt, "Response expected\n");
    goto err;
  }

  if (iwl_rx_packet_payload_len(hcmd.resp_pkt) != sizeof(*resp) + sizeof(*report)) {
    IWL_ERR(fwrt, "Invalid size for power-save report response (%u instead of %lu)\n",
            iwl_rx_packet_payload_len(hcmd.resp_pkt), sizeof(*resp) + sizeof(*report));
    ret = -EINVAL;
    goto err;
  }

  resp = (struct iwl_dhc_cmd_resp*)hcmd.resp_pkt->data;
  if (le32_to_cpu(resp->status) != 1) {
    IWL_ERR(fwrt, "response status is not success: %d\n", resp->status);
    ret = -EINVAL;
    goto err;
  }

  report = (struct iwl_ps_report*)resp->data;

  return scnprintf(
      buf, size, "power-save report:\n%s %u\n%s %u\n%s %u\n%s %u\n%s %u\n%s %u\n%s %u\n",
      "sleep_allowed_count", le32_to_cpu(report->sleep_allowed_count), "sleep_time",
      le32_to_cpu(report->sleep_time), "max_sleep_time", le32_to_cpu(report->max_sleep_time),
      "missed_beacon_count", le32_to_cpu(report->missed_beacon_count),
      "missed_3_consecutive_beacon_count", le32_to_cpu(report->missed_3_consecutive_beacon_count),
      "ps_flags", le32_to_cpu(report->ps_flags), "max_active_duration",
      le32_to_cpu(report->max_active_duration));

err:
  return ret ?: -EIO;
}

static ssize_t iwl_dbgfs_ps_report_umac_read(struct iwl_fw_runtime* fwrt, size_t size, char* buf) {
  return iwl_dbgfs_ps_report_read(fwrt, size, buf, DHC_TARGET_UMAC);
}

FWRT_DEBUGFS_READ_FILE_OPS(ps_report_umac, 224);

static ssize_t iwl_dbgfs_ps_report_lmac_read(struct iwl_fw_runtime* fwrt, size_t size, char* buf) {
  // LMAC value is 0 for backwards compatibility
  return iwl_dbgfs_ps_report_read(fwrt, size, buf, 0);
}

FWRT_DEBUGFS_READ_FILE_OPS(ps_report_lmac, 224);

#endif

int iwl_fwrt_dbgfs_register(struct iwl_fw_runtime* fwrt, struct dentry* dbgfs_dir) {
  INIT_DELAYED_WORK(&fwrt->timestamp.wk, iwl_fw_timestamp_marker_wk);
  FWRT_DEBUGFS_ADD_FILE(timestamp_marker, dbgfs_dir, 0200);
  FWRT_DEBUGFS_ADD_FILE(send_hcmd, dbgfs_dir, 0200);
#ifdef CPTCFG_IWLWIFI_DEBUG_HOST_CMD_ENABLED
  if (fw_has_capa(&fwrt->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TLC_OFFLOAD)) {
    FWRT_DEBUGFS_ADD_FILE(tpc_enable, dbgfs_dir, 0600);
    FWRT_DEBUGFS_ADD_FILE(tpc_stats, dbgfs_dir, 0400);
  }
  FWRT_DEBUGFS_ADD_FILE(ps_report_umac, dbgfs_dir, 0400);
  FWRT_DEBUGFS_ADD_FILE(ps_report_lmac, dbgfs_dir, 0400);
  FWRT_DEBUGFS_ADD_FILE(send_dhc, dbgfs_dir, 0200);
#endif
  return 0;
err:
  IWL_ERR(fwrt, "Can't create the fwrt debugfs directory\n");
  return -ENOMEM;
}