/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "include/ese/ese.h"
#include "include/ese/log.h"

static const char kUnknownHw[] = "unknown hw";
static const char kNullEse[] = "NULL EseInterface";
static const char *kEseErrorMessages[] = {
    "Hardware supplied no transceive implementation.",
    "Timed out polling for value.",
};
#define ESE_MESSAGES(x) (sizeof(x) / sizeof((x)[0]))

ESE_API const char *ese_name(const struct EseInterface *ese) {
  if (!ese) {
    return kNullEse;
  }
  if (ese->ops->name) {
    return ese->ops->name;
  }
  return kUnknownHw;
}

ESE_API int ese_open(struct EseInterface *ese, void *hw_opts) {
  if (!ese) {
    return -1;
  }
  ALOGV("opening interface '%s'", ese_name(ese));
  ese->error.is_err = false;
  ese->error.code = 0;
  if (ese->ops->open) {
    return ese->ops->open(ese, hw_opts);
  }
  return 0;
}

ESE_API const char *ese_error_message(const struct EseInterface *ese) {
  return ese->error.message;
}

ESE_API int ese_error_code(const struct EseInterface *ese) {
  return ese->error.code;
}

ESE_API bool ese_error(const struct EseInterface *ese) {
  return ese->error.is_err;
}

ESE_API void ese_set_error(struct EseInterface *ese, int code) {
  if (!ese) {
    return;
  }
  /* Negative values are reserved for ESE_API wide messages. */
  ese->error.code = code;
  ese->error.is_err = true;
  if (code < 0) {
    code = -(code + 1); /* Start at 0. */
    if ((uint32_t)(code) >= ESE_MESSAGES(kEseErrorMessages)) {
      LOG_ALWAYS_FATAL("Unknown global error code passed to ese_set_error(%d)",
                       code);
    }
    ese->error.message = kEseErrorMessages[code];
    return;
  }
  if ((uint32_t)(code) >= ese->ops->errors_count) {
    LOG_ALWAYS_FATAL("Unknown hw error code passed to ese_set_error(%d)", code);
  }
  ese->error.message = ese->ops->errors[code];
}

/* Blocking. */
ESE_API int ese_transceive(struct EseInterface *ese, const uint8_t *tx_buf,
                           uint32_t tx_len, uint8_t *rx_buf, uint32_t rx_max) {
  const struct EseSgBuffer tx = {
      .c_base = tx_buf, .len = tx_len,
  };
  struct EseSgBuffer rx = {
      .base = rx_buf, .len = rx_max,
  };
  return ese_transceive_sg(ese, &tx, 1, &rx, 1);
}

ESE_API int ese_transceive_sg(struct EseInterface *ese,
                              const struct EseSgBuffer *tx_bufs,
                              uint32_t tx_segs, struct EseSgBuffer *rx_bufs,
                              uint32_t rx_segs) {
  uint32_t recvd = 0;
  if (!ese) {
    return -1;
  }
  if (ese->error.is_err) {
    return -1;
  }
  if (ese->ops->transceive) {
    recvd = ese->ops->transceive(ese, tx_bufs, tx_segs, rx_bufs, rx_segs);
    return ese_error(ese) ? -1 : recvd;
  }

  ese_set_error(ese, kEseGlobalErrorNoTransceive);
  return -1;
}

ESE_API void ese_close(struct EseInterface *ese) {
  if (!ese) {
    return;
  }
  ALOGV("closing interface '%s'", ese_name(ese));
  if (!ese->ops->close) {
    return;
  }
  ese->ops->close(ese);
}