/******************************************************************************
 *
 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2013 - 2015 Intel Mobile Communications 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 "iwl-drv.h"
#include "iwl-io.h"
#include "iwl-prph.h"
#include "iwl-tm-infc.h"
#include "iwl-trans.h"

static int iwl_tm_send_hcmd(struct iwl_testmode* testmode, struct iwl_tm_data* data_in,
                            struct iwl_tm_data* data_out) {
  struct iwl_tm_cmd_request* hcmd_req = data_in->data;
  struct iwl_tm_cmd_request* cmd_resp;
  uint32_t reply_len, resp_size;
  struct iwl_rx_packet* pkt;
  struct iwl_host_cmd host_cmd = {
      .id = hcmd_req->id,
      .data[0] = hcmd_req->data,
      .len[0] = hcmd_req->len,
      .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
  };
  int ret;

  if (!testmode->send_hcmd) {
    return -EOPNOTSUPP;
  }

  if (hcmd_req->want_resp) {
    host_cmd.flags |= CMD_WANT_SKB;
  }

  mutex_lock(testmode->mutex);
  ret = testmode->send_hcmd(testmode->op_mode, &host_cmd);
  mutex_unlock(testmode->mutex);
  if (ret) {
    return ret;
  }
  /* if no reply is required, we are done */
  if (!(host_cmd.flags & CMD_WANT_SKB)) {
    return 0;
  }

  /* Retrieve response packet */
  pkt = host_cmd.resp_pkt;
  reply_len = iwl_rx_packet_len(pkt);

  /* Set response data */
  resp_size = sizeof(struct iwl_tm_cmd_request) + reply_len;
  cmd_resp = kzalloc(resp_size, GFP_KERNEL);
  if (!cmd_resp) {
    ret = -ENOMEM;
    goto out;
  }
  cmd_resp->id = hcmd_req->id;
  cmd_resp->len = reply_len;
  memcpy(cmd_resp->data, &(pkt->hdr), reply_len);

  data_out->data = cmd_resp;
  data_out->len = resp_size;
  ret = 0;

out:
  iwl_free_resp(&host_cmd);
  return ret;
}

static void iwl_tm_execute_reg_ops(struct iwl_testmode* testmode,
                                   struct iwl_tm_regs_request* request,
                                   struct iwl_tm_regs_request* result) {
  struct iwl_tm_reg_op* cur_op;
  uint32_t idx, read_idx;

  for (idx = 0, read_idx = 0; idx < request->num; idx++) {
    cur_op = &request->reg_ops[idx];

    if (cur_op->op_type == IWL_TM_REG_OP_READ) {
      cur_op->value = iwl_read32(testmode->trans, cur_op->address);
      memcpy(&result->reg_ops[read_idx], cur_op, sizeof(*cur_op));
      read_idx++;
    } else {
      /* IWL_TM_REG_OP_WRITE is the only possible option */
      iwl_write32(testmode->trans, cur_op->address, cur_op->value);
    }
  }
}

static int iwl_tm_reg_ops(struct iwl_testmode* testmode, struct iwl_tm_data* data_in,
                          struct iwl_tm_data* data_out) {
  struct iwl_tm_reg_op* cur_op;
  struct iwl_tm_regs_request* request = data_in->data;
  struct iwl_tm_regs_request* result;
  uint32_t result_size;
  uint32_t idx, read_idx;
  bool is_grab_nic_access_required = true;
  unsigned long flags;

  /* Calculate result size (result is returned only for read ops) */
  for (idx = 0, read_idx = 0; idx < request->num; idx++) {
    if (request->reg_ops[idx].op_type == IWL_TM_REG_OP_READ) {
      read_idx++;
    }
    /* check if there is an operation that it is not */
    /* in the CSR range (0x00000000 - 0x000003FF)    */
    /* and not in the AL range           */
    cur_op = &request->reg_ops[idx];
    if (IS_AL_ADDR(cur_op->address) || cur_op->address < HBUS_BASE) {
      is_grab_nic_access_required = false;
    }
  }
  result_size = sizeof(struct iwl_tm_regs_request) + read_idx * sizeof(struct iwl_tm_reg_op);

  result = kzalloc(result_size, GFP_KERNEL);
  if (!result) {
    return -ENOMEM;
  }
  result->num = read_idx;
  if (is_grab_nic_access_required) {
    if (!iwl_trans_grab_nic_access(testmode->trans, &flags)) {
      kfree(result);
      return -EBUSY;
    }
    iwl_tm_execute_reg_ops(testmode, request, result);
    iwl_trans_release_nic_access(testmode->trans, &flags);
  } else {
    iwl_tm_execute_reg_ops(testmode, request, result);
  }

  data_out->data = result;
  data_out->len = result_size;

  return 0;
}

static int iwl_tm_get_dev_info(struct iwl_testmode* testmode, struct iwl_tm_data* data_out) {
  struct iwl_tm_dev_info* dev_info;
  const uint8_t driver_ver[] = BACKPORTS_GIT_TRACKED;

  dev_info = kzalloc(sizeof(*dev_info) + (strlen(driver_ver) + 1) * sizeof(uint8_t), GFP_KERNEL);
  if (!dev_info) {
    return -ENOMEM;
  }

  dev_info->dev_id = testmode->trans->hw_id;
  dev_info->fw_ver = testmode->fw->ucode_ver;
  dev_info->vendor_id = PCI_VENDOR_ID_INTEL;
  dev_info->silicon_step = CSR_HW_REV_STEP(testmode->trans->hw_rev);

  /* TODO: Assign real value when feature is implemented */
  dev_info->build_ver = 0x00;

  strcpy(dev_info->driver_ver, driver_ver);

  data_out->data = dev_info;
  data_out->len = sizeof(*dev_info);

  return 0;
}

static int iwl_tm_indirect_read(struct iwl_testmode* testmode, struct iwl_tm_data* data_in,
                                struct iwl_tm_data* data_out) {
  struct iwl_trans* trans = testmode->trans;
  struct iwl_tm_sram_read_request* cmd_in = data_in->data;
  uint32_t addr = cmd_in->offset;
  uint32_t size = cmd_in->length;
  uint32_t *buf32, size32, i;
  unsigned long flags;

  if (size & (sizeof(uint32_t) - 1)) {
    return -EINVAL;
  }

  data_out->data = kmalloc(size, GFP_KERNEL);
  if (!data_out->data) {
    return -ENOMEM;
  }

  data_out->len = size;

  size32 = size / sizeof(uint32_t);
  buf32 = data_out->data;

  mutex_lock(testmode->mutex);

  /* Hard-coded periphery absolute address */
  if (addr >= IWL_ABS_PRPH_START && addr < IWL_ABS_PRPH_START + PRPH_END) {
    if (!iwl_trans_grab_nic_access(trans, &flags)) {
      mutex_unlock(testmode->mutex);
      return -EBUSY;
    }
    for (i = 0; i < size32; i++) {
      buf32[i] = iwl_trans_read_prph(trans, addr + i * sizeof(uint32_t));
    }
    iwl_trans_release_nic_access(trans, &flags);
  } else {
    /* target memory (SRAM) */
    iwl_trans_read_mem(trans, addr, buf32, size32);
  }

  mutex_unlock(testmode->mutex);
  return 0;
}

static int iwl_tm_indirect_write(struct iwl_testmode* testmode, struct iwl_tm_data* data_in) {
  struct iwl_trans* trans = testmode->trans;
  struct iwl_tm_sram_write_request* cmd_in = data_in->data;
  uint32_t addr = cmd_in->offset;
  uint32_t size = cmd_in->len;
  uint8_t* buf = cmd_in->buffer;
  uint32_t *buf32 = (uint32_t*)buf, size32 = size / sizeof(uint32_t);
  unsigned long flags;
  uint32_t val, i;

  mutex_lock(testmode->mutex);
  if (addr >= IWL_ABS_PRPH_START && addr < IWL_ABS_PRPH_START + PRPH_END) {
    /* Periphery writes can be 1-3 bytes long, or DWORDs */
    if (size < 4) {
      memcpy(&val, buf, size);
      if (!iwl_trans_grab_nic_access(trans, &flags)) {
        mutex_unlock(testmode->mutex);
        return -EBUSY;
      }
      iwl_write32(trans, HBUS_TARG_PRPH_WADDR, (addr & 0x000FFFFF) | ((size - 1) << 24));
      iwl_write32(trans, HBUS_TARG_PRPH_WDAT, val);
      iwl_trans_release_nic_access(trans, &flags);
    } else {
      if (size % sizeof(uint32_t)) {
        mutex_unlock(testmode->mutex);
        return -EINVAL;
      }

      for (i = 0; i < size32; i++) {
        iwl_write_prph(trans, addr + i * sizeof(uint32_t), buf32[i]);
      }
    }
  } else {
    iwl_trans_write_mem(trans, addr, buf32, size32);
  }
  mutex_unlock(testmode->mutex);

  return 0;
}

static int iwl_tm_get_fw_info(struct iwl_testmode* testmode, struct iwl_tm_data* data_out) {
  struct iwl_tm_get_fw_info* fw_info;
  uint32_t api_len, capa_len;
  uint32_t* bitmap;
  int i;

  if (!testmode->fw_major_ver || !testmode->fw_minor_ver) {
    return -EOPNOTSUPP;
  }

  api_len = 4 * DIV_ROUND_UP(NUM_IWL_UCODE_TLV_API, 32);
  capa_len = 4 * DIV_ROUND_UP(NUM_IWL_UCODE_TLV_CAPA, 32);

  fw_info = kzalloc(sizeof(*fw_info) + api_len + capa_len, GFP_KERNEL);
  if (!fw_info) {
    return -ENOMEM;
  }

  fw_info->fw_major_ver = testmode->fw_major_ver;
  fw_info->fw_minor_ver = testmode->fw_minor_ver;
  fw_info->fw_capa_api_len = api_len;
  fw_info->fw_capa_flags = testmode->fw->ucode_capa.flags;
  fw_info->fw_capa_len = capa_len;

  bitmap = (uint32_t*)fw_info->data;
  for (i = 0; i < NUM_IWL_UCODE_TLV_API; i++) {
    if (fw_has_api(&testmode->fw->ucode_capa, (__force iwl_ucode_tlv_api_t)i)) {
      bitmap[i / 32] |= BIT(i % 32);
    }
  }

  bitmap = (uint32_t*)(fw_info->data + api_len);
  for (i = 0; i < NUM_IWL_UCODE_TLV_CAPA; i++) {
    if (fw_has_capa(&testmode->fw->ucode_capa, (__force iwl_ucode_tlv_capa_t)i)) {
      bitmap[i / 32] |= BIT(i % 32);
    }
  }

  data_out->data = fw_info;
  data_out->len = sizeof(*fw_info) + api_len + capa_len;

  return 0;
}

/**
 * iwl_tm_execute_cmd - Implementation of test command executor
 * @testmode:     iwl_testmode, holds all relevant data for execution
 * @cmd:      User space command's index
 * @data_in:      Input data. "data" field is to be casted to relevant
 *        data structure. All verification must be done in the
 *        caller function, therefor assuming that input data
 *        length is valid.
 * @data_out:     Will be allocated inside, freeing is in the caller's
 *        responsibility
 */
int iwl_tm_execute_cmd(struct iwl_testmode* testmode, uint32_t cmd, struct iwl_tm_data* data_in,
                       struct iwl_tm_data* data_out) {
  const struct iwl_test_ops* test_ops;
  bool cmd_supported = false;
  int ret;

  if (!testmode->trans->op_mode) {
    IWL_ERR(testmode->trans, "No op_mode!\n");
    return -ENODEV;
  }
  if (WARN_ON_ONCE(!testmode->op_mode || !data_in)) {
    return -EINVAL;
  }

  test_ops = &testmode->trans->op_mode->ops->test_ops;

  if (test_ops->cmd_exec_start) {
    ret = test_ops->cmd_exec_start(testmode);
    if (ret) {
      return ret;
    }
  }

  if (test_ops->cmd_exec) {
    ret = test_ops->cmd_exec(testmode, cmd, data_in, data_out, &cmd_supported);
  }

  if (cmd_supported) {
    goto out;
  }

  switch (cmd) {
    case IWL_TM_USER_CMD_HCMD:
      ret = iwl_tm_send_hcmd(testmode, data_in, data_out);
      break;
    case IWL_TM_USER_CMD_REG_ACCESS:
      ret = iwl_tm_reg_ops(testmode, data_in, data_out);
      break;
    case IWL_TM_USER_CMD_SRAM_WRITE:
      ret = iwl_tm_indirect_write(testmode, data_in);
      break;
    case IWL_TM_USER_CMD_SRAM_READ:
      ret = iwl_tm_indirect_read(testmode, data_in, data_out);
      break;
    case IWL_TM_USER_CMD_GET_DEVICE_INFO:
      ret = iwl_tm_get_dev_info(testmode, data_out);
      break;
    case IWL_TM_USER_CMD_GET_FW_INFO:
      ret = iwl_tm_get_fw_info(testmode, data_out);
      break;
    default:
      ret = -EOPNOTSUPP;
      break;
  }

out:
  if (test_ops->cmd_exec_end) {
    test_ops->cmd_exec_end(testmode);
  }
  return ret;
}

void iwl_tm_init(struct iwl_trans* trans, const struct iwl_fw* fw, struct mutex* mutex,
                 void* op_mode) {
  struct iwl_testmode* testmode = &trans->testmode;

  testmode->trans = trans;
  testmode->fw = fw;
  testmode->mutex = mutex;
  testmode->op_mode = op_mode;

  if (trans->op_mode->ops->test_ops.send_hcmd) {
    testmode->send_hcmd = trans->op_mode->ops->test_ops.send_hcmd;
  }
}
IWL_EXPORT_SYMBOL(iwl_tm_init);

void iwl_tm_set_fw_ver(struct iwl_trans* trans, uint32_t fw_major_ver, uint32_t fw_minor_var) {
  struct iwl_testmode* testmode = &trans->testmode;

  testmode->fw_major_ver = fw_major_ver;
  testmode->fw_minor_ver = fw_minor_var;
}
IWL_EXPORT_SYMBOL(iwl_tm_set_fw_ver);