libese-hw/ese_hw_echo.c

/*
 * Copyright (C) 2016 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.
 *
 * Implement a simple T=1 echo endpoint.
 */

#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "../libese-teq1/include/ese/teq1.h"
#include "../libese/include/ese/ese.h"
#include "../libese/include/ese/log.h"

struct EchoState {
  struct Teq1Frame frame;
  uint8_t *rx_fill;
  uint8_t *tx_sent;
  int recvd;
};

#define ECHO_STATE(ese) (*(struct EchoState **)(&ese->pad[1]))

static int echo_open(struct EseInterface *ese, void *hw_opts) {
  struct EchoState *es = hw_opts; /* shorter than __attribute */
  struct EchoState **es_ptr;
  if (sizeof(ese->pad) < sizeof(struct EchoState *)) {
    /* This is a compile-time correctable error only. */
    ALOGE("Pad size too small to use Echo HW (%zu < %zu)", sizeof(ese->pad),
          sizeof(struct EchoState *));
    return -1;
  }
  es_ptr = &ECHO_STATE(ese);
  *es_ptr = malloc(sizeof(struct EchoState));
  if (!*es_ptr) {
    return -1;
  }
  es = ECHO_STATE(ese);
  es->rx_fill = &es->frame.header.NAD;
  es->tx_sent = es->rx_fill;
  es->recvd = 0;
  return 0;
}

static void echo_close(struct EseInterface *ese) {
  struct EchoState *es;
  es = ECHO_STATE(ese);
  if (!es) {
    return;
  }
  free(es);
  es = NULL;
}

static uint32_t echo_receive(struct EseInterface *ese, uint8_t *buf,
                             uint32_t len, int complete) {
  struct EchoState *es = ECHO_STATE(ese);
  ALOGV("interface attempting to read data");
  if (!es->recvd) {
    return 0;
  }

  if (len > sizeof(es->frame) - (es->tx_sent - &es->frame.header.NAD)) {
    return 0;
  }

  /* NAD was polled for so skip it. */
  memcpy(buf, es->tx_sent, len);
  es->tx_sent += len;
  if (complete) {
    es->tx_sent = &es->frame.header.NAD;
    es->recvd = 0;
    ALOGV("card sent a frame");
  }
  return sizeof(es->frame.header) + es->frame.header.LEN;
}

static uint32_t echo_transmit(struct EseInterface *ese, const uint8_t *buf,
                              uint32_t len, int complete) {
  struct EchoState *es = ECHO_STATE(ese);
  ALOGV("interface transmitting data");
  if (len > sizeof(es->frame) - (es->rx_fill - &es->frame.header.NAD)) {
    return 0;
  }
  memcpy(es->rx_fill, buf, len);
  es->rx_fill += len;
  es->recvd = complete;
  if (complete) {
    es->frame.header.NAD = 0x00;
    if (teq1_compute_LRC(&es->frame) != es->frame.INF[es->frame.header.LEN]) {
      ALOGV("card received frame with bad LRC");
      return 0;
    }
    ALOGV("card received valid frame");
    es->rx_fill = &es->frame.header.NAD;
  }
  return len;
}

static int echo_poll(struct EseInterface *ese, uint8_t poll_for, float timeout,
                     int complete) {
  struct EchoState *es = ECHO_STATE(ese);
  const struct Teq1ProtocolOptions *opts = ese->ops->opts;
  ALOGV("interface polling for start of frame/host node address: %x", poll_for);
  /* In reality, we should be polling at intervals up to the timeout. */
  if (timeout > 0.0) {
    usleep(timeout * 1000);
  }
  if (poll_for == opts->host_address) {
    ALOGV("interface received NAD");
    if (!complete) {
      es->tx_sent++; /* Consume the polled byte: NAD */
    }
    return 1;
  }
  return -1;
}

int echo_preprocess(const struct Teq1ProtocolOptions *const opts,
                    struct Teq1Frame *frame, int tx) {
  if (tx) {
    /* Recompute the LRC with the NAD of 0x00 */
    frame->header.NAD = 0x00;
    frame->INF[frame->header.LEN] = teq1_compute_LRC(frame);
    frame->header.NAD = opts->node_address;
    ALOGV("interface is preprocessing outbound frame");
  } else {
    /* Replace the NAD with 0x00 so the LRC check passes. */
    frame->header.NAD = 0x00;
    ALOGV("interface is preprocessing inbound frame");
  }
  return 0;
}

static const struct Teq1ProtocolOptions kTeq1Options = {
    .host_address = 0xAA,
    .node_address = 0xBB,
    .bwt = 3.14152f,
    .etu = 1.0f,
    .preprocess = &echo_preprocess,
};

uint32_t echo_transceive(struct EseInterface *ese,
                         const struct EseSgBuffer *tx_buf, uint32_t tx_len,
                         struct EseSgBuffer *rx_buf, uint32_t rx_len) {
  return teq1_transceive(ese, &kTeq1Options, tx_buf, tx_len, rx_buf, rx_len);
}

static const char *kErrorMessages[] = {
    "T=1 hard failure.",        /* TEQ1_ERROR_HARD_FAIL */
    "T=1 abort.",               /* TEQ1_ERROR_ABORT */
    "T=1 device reset failed.", /* TEQ1_ERROR_DEVICE_ABORT */
};

static const struct EseOperations ops = {
    .name = "eSE Echo Hardware (fake)",
    .open = &echo_open,
    .hw_receive = &echo_receive,
    .hw_transmit = &echo_transmit,
    .transceive = &echo_transceive,
    .poll = &echo_poll,
    .close = &echo_close,
    .opts = &kTeq1Options,
    .errors = kErrorMessages,
    .errors_count = sizeof(kErrorMessages),
};
ESE_DEFINE_HW_OPS(ESE_HW_ECHO, ops);