Logo Search packages:      
Sourcecode: alsa-tools version File versions  Download package

ld10k1_debug.c

/*
 *  EMU10k1 loader
 *
 *  Copyright (c) 2003,2004 by Peter Zubaj
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <alsa/asoundlib.h>
#include "ld10k1.h"
#include "ld10k1_fnc.h"
#include "ld10k1_fnc1.h"
#include "ld10k1_debug.h"
#include "ld10k1_error.h"
#include "ld10k1_tram.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

static char *usage_str[] = {
      "NONE",
      "NORMAL",
      "CONST",
      "DYNAMIC"
};

char debug_line[1000];
int send_debug_line(int data_conn)
{
      return send_response(data_conn, FNC_CONTINUE, 0, debug_line, strlen(debug_line) + 1);
}

int ld10k1_debug_new_gpr_read_one(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr, unsigned int idx)
{
      int usage;
      int value;
      int ref_count;
      int modified;

      modified = dsp_mgr->regs[idx].modified;
      usage = dsp_mgr->regs[idx].gpr_usage;
      value = dsp_mgr->regs[idx].val;
      ref_count = dsp_mgr->regs[idx].ref;

      sprintf(debug_line, "%c 0x%03x : %-12s  0x%08x  %3d\n",
                  modified ? '*' : ' ',
                  idx,
                  usage_str[usage],
                  value,
                  ref_count);
      return send_debug_line(data_conn);
}

int ld10k1_debug_new_gpr_read_hdr(int data_conn)
{
      sprintf(debug_line, "M Idx     Usage         Value         Ref\n");
      return send_debug_line(data_conn);
}

static int ld10k1_debug_new_gpr_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      int err;

      sprintf(debug_line, "FX8010 GPR List\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      if ((err = ld10k1_debug_new_gpr_read_hdr(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->regs_max_count; i++)
            if (dsp_mgr->regs[i].used)
                  if ((err = ld10k1_debug_new_gpr_read_one(data_conn, dsp_mgr, i)) < 0)
                        return err;
      return 0;
}

static int ld10k1_debug_new_fx_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      int err;

      sprintf(debug_line, "FX8010 FX List\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->fx_count; i++) {
            sprintf(debug_line, "%03x : %-20s\n",
                  i,
                  dsp_mgr->fxs[i].name ? dsp_mgr->fxs[i].name : "");
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }
      return 0;
}

static int ld10k1_debug_new_in_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      int err;

      sprintf(debug_line, "FX8010 IN List\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->in_count; i++) {
            sprintf(debug_line, "%03x : %-20s\n",
                  i,
                  dsp_mgr->ins[i].name ? dsp_mgr->ins[i].name : "");
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }
      return 0;
}

static int ld10k1_debug_new_out_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      int err;

      sprintf(debug_line, "FX8010 OUT List\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->out_count; i++) {
            sprintf(debug_line, "%03x : %-20s\n",
                  i,
                  dsp_mgr->outs[i].name ? dsp_mgr->outs[i].name : "");
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }
      return 0;
}

int ld10k1_debug_new_const_read_one(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr, unsigned int idx)
{
      int hw;
      int value;
      int ref_count;

      hw = dsp_mgr->consts[idx].hw;
      value = dsp_mgr->consts[idx].const_val;
      ref_count = dsp_mgr->consts[idx].ref;

      sprintf(debug_line, "0x%03x : 0x%08x  %c  %3d\n",
                  idx,
                  value,
                  hw ? '*' : ' ',
                  ref_count);
      return send_debug_line(data_conn);
}

int ld10k1_debug_new_const_read_hdr(int data_conn)
{
      sprintf(debug_line, "Idx     Value       HW   Ref\n");
      return send_debug_line(data_conn);
}

static int ld10k1_debug_new_const_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      int err;

      sprintf(debug_line, "CONST List\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      if ((err = ld10k1_debug_new_const_read_hdr(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->consts_max_count; i++)
            if (dsp_mgr->consts[i].used)
                  if ((err = ld10k1_debug_new_const_read_one(data_conn, dsp_mgr, i)) < 0)
                        return err;
      return 0;
}

char *instr_name[] = {
      "MACS",
      "MACS1",
      "MACW",
      "MACW1",
      "MACINTS",
      "MACINTW",
      "ACC3",
      "MACMV",
      "ANDXOR",
      "TSTNEG",
      "LIMIT",
      "LIMIT1",
      "LOG",
      "EXP",
      "INTERP",
      "SKIP",
};

static void ld10k1_debug_decode_preg_idx(char *type, unsigned int reg)
{
      switch ((reg & EMU10K1_PREG_TYPE_MASK) >> 28) {
            case EMU10K1_PREG_TYPE_IN:
                  sprintf(type, "IN(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_OUT:
                  sprintf(type, "OUT(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_CONST:
                  sprintf(type, "CON(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_STA:
                  sprintf(type, "STA(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_DYN:
                  sprintf(type, "DYN(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_HW:
                  sprintf(type, "HW(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_CTL:
                  sprintf(type, "CTL(%03d, %03d)", (reg & ~EMU10K1_PREG_TYPE_MASK) >> 8, reg & ~EMU10K1_PREG_TYPE_MASK & 0xFF);
                  break;
            case EMU10K1_PREG_TYPE_TRAM_DATA:
                  sprintf(type, "TD(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            case EMU10K1_PREG_TYPE_TRAM_ADDR:
                  sprintf(type, "TA(%03d)", reg & ~EMU10K1_PREG_TYPE_MASK);
                  break;
            default:
                  sprintf(type, "??? 0x%08x", reg);
      }
}

int ld10k1_debug_new_code_read_one(int data_conn, int preg, ld10k1_instr_t *instr, unsigned int idx)
{
      char type1[100];
      char type2[100];
      char type3[100];
      char type4[100];

      if (instr->used) {
            if (preg) {
                  ld10k1_debug_decode_preg_idx(type1, instr->arg[0]);
                  ld10k1_debug_decode_preg_idx(type2, instr->arg[1]);
                  ld10k1_debug_decode_preg_idx(type3, instr->arg[2]);
                  ld10k1_debug_decode_preg_idx(type4, instr->arg[3]);

                  sprintf(debug_line, "%c 0x%03x : %-10s %s, %s, %s, %s\n",
                        instr->modified ? '*' : ' ',
                        idx,
                        instr_name[instr->op_code],
                        type1,
                        type2,
                        type3,
                        type4);
            } else {
                  sprintf(debug_line, "%c 0x%03x : %-10s 0x%03x, 0x%03x, 0x%03x, 0x%03x\n",
                        instr->modified ? '*' : ' ',
                        idx,
                        instr_name[instr->op_code],
                        instr->arg[0],
                        instr->arg[1],
                        instr->arg[2],
                        instr->arg[3]);
            }

            return send_debug_line(data_conn);
      } else {
            sprintf(debug_line, "%c 0x%03x : NOT USED\n",
                  instr->modified ? '*' : ' ',
                  idx);
            return send_debug_line(data_conn);
      }
}

int ld10k1_debug_new_code_read_hdr(int data_conn)
{
      sprintf(debug_line, "M Idx     OPCODE\n");
      return send_debug_line(data_conn);
}

static int ld10k1_debug_new_code_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      int err;
      ld10k1_instr_t *instr;

      sprintf(debug_line, "FX8010 Code\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      if ((err = ld10k1_debug_new_code_read_hdr(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->instr_count; i++) {
            instr = &(dsp_mgr->instr[i]);
            if (instr->used)
                  if ((err = ld10k1_debug_new_code_read_one(data_conn, 0, instr, i)) < 0)
                        return err;
      }
      return 0;
}

static int ld10k1_debug_new_tram_info_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i, j;
      int err;

      char *req_pos_str;
      char *pos_str;

      ld10k1_tram_acc_t *tram_acc;
      unsigned int data, addr;

      int ifree = dsp_mgr->i_tram.size;
      int efree = dsp_mgr->e_tram.size;

      sprintf(debug_line, "TRAM\n\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;

      sprintf(debug_line, "Internal tram size: 0x%08x\n", dsp_mgr->i_tram.size);
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      sprintf(debug_line, "External tram size: 0x%08x\n", dsp_mgr->e_tram.size);
      if ((err = send_debug_line(data_conn)) < 0)
            return err;

      sprintf(debug_line, "\nTram groups:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;

      for (i = 0; i < dsp_mgr->max_tram_grp; i++) {
            if (dsp_mgr->tram_grp[i].used) {
                  sprintf(debug_line, "%03d  %10s  ", i, dsp_mgr->tram_grp[i].type == TRAM_GRP_DELAY ? "DELAY" : "TABLE");
                  if ((err = send_debug_line(data_conn)) < 0)
                        return err;

                  req_pos_str = "NONE";
                  if (dsp_mgr->tram_grp[i].req_pos == TRAM_POS_AUTO)
                        req_pos_str = "AUTO";
                  else if (dsp_mgr->tram_grp[i].req_pos == TRAM_POS_INTERNAL)
                        req_pos_str = "INTERNAL";
                  else if (dsp_mgr->tram_grp[i].req_pos == TRAM_POS_EXTERNAL)
                        req_pos_str = "EXTERNAL";

                  pos_str = "NONE";
                  if (dsp_mgr->tram_grp[i].pos == TRAM_POS_INTERNAL) {
                        pos_str = "INTERNAL";
                        ifree -= dsp_mgr->tram_grp[i].size;
                  } else if (dsp_mgr->tram_grp[i].pos == TRAM_POS_EXTERNAL) {
                        pos_str = "EXTERNAL";
                        efree -= dsp_mgr->tram_grp[i].size;
                  }

                  sprintf(debug_line, "%10s  %10s   %08x  %08x  %03d\n", req_pos_str, pos_str,
                        dsp_mgr->tram_grp[i].size, dsp_mgr->tram_grp[i].offset, dsp_mgr->tram_grp[i].acc_count);
                  if ((err = send_debug_line(data_conn)) < 0)
                        return err;

                  for (j = 0; j < dsp_mgr->max_tram_acc; j++) {
                        tram_acc = &(dsp_mgr->tram_acc[j]);

                        ld10k1_tram_get_hwacc(dsp_mgr, tram_acc->hwacc, &addr, &data);
                        if ((tram_acc->used) && (tram_acc->grp == i)) {
                              sprintf(debug_line, "  %c%c%c  Off:0x%08x  HWacc:%03d  ADDR:0x%08x   DATA:0x%08x\n",
                                    (tram_acc->type & TRAM_ACC_READ) ? 'R' : '-',
                                    (tram_acc->type & TRAM_ACC_WRITE) ? 'W' : '-',
                                    (tram_acc->type & TRAM_ACC_ZERO) ? 'Z' : '-',
                                    tram_acc->offset,
                                    tram_acc->hwacc,
                                    addr,
                                    data);
                              if ((err = send_debug_line(data_conn)) < 0)
                                    return err;
                        }
                  }
            }
      }
      return 0;
}

int ld10k1_debug_new_patch_read1(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr, ld10k1_patch_t *patch)
{
      int i, j;
      int err;

      ld10k1_conn_point_t *point;

      sprintf(debug_line, "Patch name: %s\n\n", patch->patch_name);
      if ((err = send_debug_line(data_conn)) < 0)
            return err;

      /* in list */
      sprintf(debug_line, "IN registers:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->in_count; i++) {
            sprintf(debug_line, "%03d   %s  ->  0x%08x\n", i,
                  patch->ins[i].name ? patch->ins[i].name : "",
                  patch->ins[i].point ? patch->ins[i].point->con_gpr_idx : 0);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;

            point = patch->ins[i].point;
            if (point != NULL)
                  for (j = 0; j < MAX_CONN_PER_POINT; j++) {
                        if (point->out_gpr_idx[j] != 0) {
                              sprintf(debug_line, "   +0x%08x\n", point->out_gpr_idx[j]);
                              if ((err = send_debug_line(data_conn)) < 0)
                                    return err;
                        }
                  }
      }

      /* out list */
      sprintf(debug_line, "OUT registers:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->out_count; i++) {
            sprintf(debug_line, "%03d   %s  ->  0x%08x\n", i,
                  patch->outs[i].name ? patch->outs[i].name : "",
                  patch->outs[i].point ? patch->outs[i].point->con_gpr_idx : 0);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }

      /* const list */
      sprintf(debug_line, "CONST registers:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->const_count; i++) {
            sprintf(debug_line, "%03d   0x%08x  ->  0x%08x\n", i,
                  patch->consts[i].const_val,
                  patch->consts[i].gpr_idx);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }

      /* sta list */
      sprintf(debug_line, "STA registers:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->sta_count; i++) {
            sprintf(debug_line, "%03d   0x%08x  ->  0x%08x\n", i,
                  patch->stas[i].const_val,
                  patch->stas[i].gpr_idx);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }

      /* hw list */
      sprintf(debug_line, "HW registers:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->hw_count; i++) {
            sprintf(debug_line, "%03d   0x%08x  ->  0x%08x\n", i,
                  patch->hws[i].reg_idx,
                  patch->hws[i].gpr_idx);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }

      /* tram list */
      sprintf(debug_line, "\nUsed tram groups:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->tram_count; i++)   {
            sprintf(debug_line, "%03d  0x%01x 0x%08x 0x%01x ->  %03d\n", i,
                  patch->tram_grp[i].grp_type,
                  patch->tram_grp[i].grp_size,
                  patch->tram_grp[i].grp_pos,
                  patch->tram_grp[i].grp_idx);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }

      /* tram acc list */
      sprintf(debug_line, "\nUsed tram acc:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->tram_acc_count; i++) {
            sprintf(debug_line, "%03d   0x%01x  0x%08x  0x%03x ->  0x%03x\n", i,
                  patch->tram_acc[i].acc_type,
                  patch->tram_acc[i].acc_offset,
                  patch->tram_acc[i].grp,
                  patch->tram_acc[i].acc_idx);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
      }

      /* cotrol list */
      sprintf(debug_line, "\nUsed controls:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->ctl_count; i++) {
            sprintf(debug_line, "%03d\n", i);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
            sprintf(debug_line, "  Name:%s\n", patch->ctl[i].name);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
            sprintf(debug_line, "  Min: 0x%08x\n", patch->ctl[i].min);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
            sprintf(debug_line, "  Max: 0x%08x\n", patch->ctl[i].max);
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
            sprintf(debug_line, "  GPRS:\n");
            if ((err = send_debug_line(data_conn)) < 0)
                  return err;
            for (j = 0; j < patch->ctl[i].count; j++) {
                  sprintf(debug_line, "    %03d  0x%08x ->  0x%08x  %c\n", j,
                        patch->ctl[i].value[j],
                        patch->ctl[i].gpr_idx[j],
                        j < patch->ctl[i].vcount ? 'v' : ' ');
                  if ((err = send_debug_line(data_conn)) < 0)
                        return err;
            }
      }

      /* instruction list */
      sprintf(debug_line, "\nCode:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;

      if ((err = ld10k1_debug_new_code_read_hdr(data_conn)) < 0)
            return err;
      for (i = 0; i < patch->instr_count; i++) {
            ld10k1_instr_t *instr;

            instr = &(patch->instr[i]);
            if ((err = ld10k1_debug_new_code_read_one(data_conn, 1, instr, i)) < 0)
                  return err;
      }
      return 0;
}

static int ld10k1_debug_new_patch_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr, int idx)
{
      ld10k1_patch_t *patch;
      patch = dsp_mgr->patch_ptr[idx];
      if (!patch)
            return LD10K1_ERR_UNKNOWN_PATCH_NUM;

      return ld10k1_debug_new_patch_read1(data_conn, dsp_mgr, patch);
}

static int ld10k1_debug_new_patch_list_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i;
      ld10k1_patch_t *patch;
      int err;

      sprintf(debug_line, "\nPatch List:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < EMU10K1_PATCH_MAX; i++) {
            patch = dsp_mgr->patch_ptr[i];
            if (patch) {
                  sprintf(debug_line, "%03d  %s\n\n", i, patch->patch_name);
                  if ((err = send_debug_line(data_conn)) < 0)
                        return err;
            }
      }
      return 0;
}

static int ld10k1_debug_new_patch_order_read(int data_conn, ld10k1_dsp_mgr_t *dsp_mgr)
{
      int i, idx;
      ld10k1_patch_t *patch;
      int err;

      sprintf(debug_line, "\nPatch order:\n");
      if ((err = send_debug_line(data_conn)) < 0)
            return err;
      for (i = 0; i < dsp_mgr->patch_count; i++) {
            idx = dsp_mgr->patch_order[i];
            patch = dsp_mgr->patch_ptr[idx];
            if (patch) {
                  sprintf(debug_line, "%03d   %03d %s\n\n", i, idx, patch->patch_name);
                  if ((err = send_debug_line(data_conn)) < 0)
                        return err;
            }
      }

      return 0;
}

int ld10k1_fnc_debug(int data_conn, int op, int size)
{
      ld10k1_fnc_debug_t debug_info;
      int err;

      if (size != sizeof(ld10k1_fnc_debug_t))
            return LD10K1_ERR_PROTOCOL;

      if ((err = receive_msg_data(data_conn, &debug_info, sizeof(ld10k1_fnc_debug_t))))
            return err;

      if (debug_info.what >= 100 && debug_info.what <= 100 + EMU10K1_PATCH_MAX) {
            if ((err = ld10k1_debug_new_patch_read(data_conn, &dsp_mgr, debug_info.what - 100)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 1) {
            /* registers */
            if ((err = ld10k1_debug_new_gpr_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 2) {
            /* registers */
            if ((err = ld10k1_debug_new_const_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 3) {
            /* instruction */
            if ((err = ld10k1_debug_new_code_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 4) {
            /* tram */
            if ((err = ld10k1_debug_new_tram_info_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 5) {
            if ((err = ld10k1_debug_new_patch_list_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 6) {
            if ((err = ld10k1_debug_new_patch_order_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 7) {
            /* fx */
            if ((err = ld10k1_debug_new_fx_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 8) {
            /* in */
            if ((err = ld10k1_debug_new_in_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else if (debug_info.what == 9) {
            /* out */
            if ((err = ld10k1_debug_new_out_read(data_conn, &dsp_mgr)) < 0)
                  return err;
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;
      } else
            if ((err = send_response_ok(data_conn)) < 0)
                  return err;

      return 0;
}

Generated by  Doxygen 1.6.0   Back to index