dummy_arm.h

/*
 * Copyright (C) 2010-2011 University of Texas at Austin
 *
 * Author: Dan Zhang <dan.zhang@mail.utexas.edu>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation
 * version 2.1 of the License.
 *
 * Copyright (C) 2009-2010 Felipe Contreras
 * Copyright (C) 2009-2010 Nokia Corporation
 * Copyright (C) 2009 Igalia S.L
 *
 * Author: Felipe Contreras <felipe.contreras@nokia.com>
 *
 * This file may be used under the terms of the GNU Lesser General Public
 * License version 2.1, a copy of which is found in LICENSE included in the
 * packaging of this file.
 */

static dmm_buffer_t *input_buffer;
static dmm_buffer_t *output_buffer;

static int dsp_handle;
static void *proc;

/*static void
signal_handler(int signal)
{
  exit(-1);
}*/

static inline struct dsp_node *
create_node(void)
{
  struct dsp_node *node;
  const struct dsp_uuid dummy_uuid = { 0x3dac26d0, 0x6d4b, 0x11dd, 0xad, 0x8b,
                       { 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 } };

  if (!dsp_register(dsp_handle, &dummy_uuid, DSP_DCD_LIBRARYTYPE, "/lib/dsp/dummy.dll64P"))
    return false;

  if (!dsp_register(dsp_handle, &dummy_uuid, DSP_DCD_NODETYPE, "/lib/dsp/dummy.dll64P"))
    return false;

  if (!dsp_node_allocate(dsp_handle, proc, &dummy_uuid, NULL, NULL, &node)) {
    pr_err("dsp node allocate failed");
    return NULL;
  }

  if (!dsp_node_create(dsp_handle, node)) {
    pr_err("dsp node create failed");
    return NULL;
  }

  pr_info("dsp node created");

  return node;
}

static inline bool
destroy_node(struct dsp_node *node)
{
  struct dsp_msg msg;

  if (node) {
    // Send a DONE message to the DSP
    msg.cmd = 0x80000000;
    msg.arg_1 = (uint32_t) input_buffer->map;
    msg.arg_2 = (uint32_t) output_buffer->map;
    dsp_node_put_message(dsp_handle, node, &msg, -1);

    if (!dsp_node_free(dsp_handle, node)) {
      pr_err("dsp node free failed");
      return false;
    }

    pr_info("dsp node deleted");
  }

  return true;
}

static inline void
configure_dsp_node(void *node,
           dmm_buffer_t *input_buffer,
           dmm_buffer_t *output_buffer)
{
  struct dsp_msg msg;

  msg.cmd = 0;
  msg.arg_1 = (uint32_t) input_buffer->map;
  msg.arg_2 = (uint32_t) output_buffer->map;
  dsp_node_put_message(dsp_handle, node, &msg, -1);
}


static inline void
setup_dmm_buffers(struct dsp_node *node, int input_size, int output_size) {
  printf("Calling dsp_node_run\n");
  if (!dsp_node_run(dsp_handle, node)) {
    pr_err("dsp node run failed");
    exit(-1);
  }
  printf("Calling dmm_buffer_new\n");
  pr_info("dsp node running");

  input_buffer = dmm_buffer_new(dsp_handle, proc, DMA_TO_DEVICE);
  output_buffer = dmm_buffer_new(dsp_handle, proc, DMA_FROM_DEVICE);
  printf("Calling dmm_buffer_allocate\n");
  dmm_buffer_allocate(input_buffer, input_size);
  dmm_buffer_allocate(output_buffer, output_size);

  dmm_buffer_map(output_buffer);
  dmm_buffer_map(input_buffer);

  configure_dsp_node(node, input_buffer, output_buffer);
}

static inline void
dsp_send(struct dsp_node *node, struct dsp_msg msg) {
  dmm_buffer_begin(input_buffer, input_buffer->size);
  dmm_buffer_begin(output_buffer, output_buffer->size);
  dsp_node_put_message(dsp_handle, node, &msg, -1);
}

// blocking DSP receive
static inline struct dsp_msg
dsp_recv(struct dsp_node *node) {
  struct dsp_msg msg;
  dsp_node_get_message(dsp_handle, node, &msg, -1);
  dmm_buffer_end(input_buffer, input_buffer->size);
  dmm_buffer_end(output_buffer, output_buffer->size);
  return msg;
}

// non-blocking DSP receive
static inline bool
dsp_irecv(struct dsp_node *node, struct dsp_msg* msg) {
  bool complete;
  complete = dsp_node_get_message(dsp_handle, node, msg, 0);
  if(complete) {
    dmm_buffer_end(input_buffer, input_buffer->size);
    dmm_buffer_end(output_buffer, output_buffer->size);
    return true;
  }
  else {
    return false;
  }
}


static inline bool
dsp_finish(struct dsp_node *node) {
  unsigned long exit_status;

  dmm_buffer_unmap(output_buffer);
  dmm_buffer_unmap(input_buffer);

  dmm_buffer_free(output_buffer);
  dmm_buffer_free(input_buffer);

  if (!dsp_node_terminate(dsp_handle, node, &exit_status)) {
    pr_err("dsp node terminate failed: %lx", exit_status);
    return false;
  }

  destroy_node(node);
  pr_info("dsp node terminated");
  return true;
}


static struct dsp_node* setup_dsp() {
  struct dsp_node *node;
  int ret = 0;

//  signal(SIGINT, signal_handler);

#ifdef DEBUG
  debug_level = 3;
#endif
  dsp_handle = dsp_open();

  if (dsp_handle < 0) {
    pr_err("dsp open failed");
    ret = -1;
    exit(ret);
  }

  if (!dsp_attach(dsp_handle, 0, NULL, &proc)) {
    pr_err("dsp attach failed");
    ret = -1;
    goto leave;
  }

  node = create_node();
  if (!node) {
    pr_err("dsp node creation failed");
    ret = -1;
    goto leave;
  }

  return node;

 leave:
  if (proc) {
    if (!dsp_detach(dsp_handle, proc)) {
      pr_err("dsp detach failed");
      ret = -1;
    }
    proc = NULL;
  }

  if (dsp_handle > 0) {
    if (dsp_close(dsp_handle) < 0) {
      pr_err("dsp close failed");
      exit(-1);
      //return -1;
    }
  }

  exit(-1);
  return node;
}