ddutils.c

speech signal process tools

/* Copyright (c) 1995 Entropic Research Laboratory, Inc. */
/* ddutils.c */
/*
 *	This is of course Copyright 1989, 1990 AT&T
 *	Unpublished source code of AT&T, no warranties, etc,
 *	and this doesn't mean we're ever going to publish it
 *	either.
 */
 

static char *sccs_id = "@(#)ddutils.c	1.4	9/26/95	ATT/ERL";

#include	<stdio.h>
int dsp32c_sm = -1;
int dsp32c_io = -1;
char    *DSP_io=NULL;	/* pointer to memory-mapped I/O registers */

#if ( defined(SUN4) || defined(SUN3) ) && !defined(OS5)

#include	<sys/ioctl.h>
#include	<sys/mman.h>
#include	"dsp32c.h"
#include	"vme32c.h"
#include	"ar.h"
#include	<filehdr.h>
#include	<scnhdr.h>
#include	<ldfcn.h>
#include	<syms.h>
#include	<storclas.h>
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<errno.h>
#define TRUE 1
#define FALSE 0
#define SURF_SM_SIZE 0x100000

typedef unsigned long ulong;

int dsp32c[6] = {-1, -1, -1, -1, -1, -1};
char	*DSP_SharedMemory=NULL;	/* Ptr to base of shared mem. */
char *dspdev = "/dev/dc0";	/* SHOULD be defined externally in main module */

/*************************************************************************/
dsp32c_is_available()
{
  int dc2;
  int dc = open("/dev/dc00",O_RDWR,0);
  if(dc >= 0) {
    close(dc);
    dc2 = dcopen("/dev/dc00");
    if(dc2 >= 0) {
      close(dc2);
      return(1);
    }
  }
  return(0);
}

/***********************************************************************/
char*
global_dc_device(sub)
     char *sub;
{
  static char dcdevice[200];
  extern char *dspdev; /* defined in each application;
			  usually "/dev/dc0" */

  if(!(sub && *sub))
    return(dspdev);
  else {
    strcpy(dcdevice,dspdev);
    strcat(dcdevice,sub);
    return(dcdevice);
  }
}

/***********************************************************************/
reverse(buf,n)			/* little endian to big endian */
     unsigned int *buf;
     int n;			/* number of chars, ie 4x nlongs */
{
  register unsigned char *in = (unsigned char*)buf,
  *out = (unsigned char*)buf;
  register unsigned char tmp1, tmp2, tmp3;
  register int i=n>>2;

  if (i<=0)
    return;
  while (i-- > 0) {
    tmp3 = *in++;
    tmp2 = *in++;
    tmp1 = *in++;
    *out++ = *in++;
    *out++ = tmp1;
    *out++ = tmp2;
    *out++ = tmp3;
  }
}

#define	MEMSIZE	(1L<<24)

dcld (dev, filename)
     int dev;
     char *filename;
{
#if !defined(TESTING_ONLY)
  register LDFILE		*ldptr;
  FILHDR			filhdr;
  SCNHDR			secthdr;
  register unsigned	sec_no;
  register int		addr,
  sect_end;
  register int		size = 0;
  register int		i;
  char			lbl_buf[10];

  if ((ldptr=ldopen(filename,NULL)) == NULL ) {
    fprintf(stderr,"Can't open %s as object file\n", filename);
    return( -1 );
  }
  ldfhread (ldptr, &filhdr);
  if (HEADER(ldptr).f_magic != DSP32CMAGIC) {
    fprintf(stderr,"%s doesn't look like object file; magic=%#o\n",
	    filename, HEADER(ldptr).f_magic);
    ldclose(ldptr);
    return (-1);
  }
  for (sec_no=1; sec_no <= HEADER(ldptr).f_nscns; sec_no++) {
    ldshread (ldptr, sec_no, &secthdr);
    sect_end = secthdr.s_paddr + secthdr.s_size;
    if (sect_end > MEMSIZE) {
      fprintf(stderr, "Object section %d outside address range",sec_no);
      ldclose(ldptr);
      return( -1 );
    }
    size += secthdr.s_size;
    if (size > MEMSIZE) {
      fprintf(stderr,
	      "Sum of section sizes too large (%d), section number %d",
	      size, sec_no);
      ldclose(ldptr);
      return(-1);
    }
    if (secthdr.s_name[0] == '\0')
      continue;			/* <== <== */
    if (secthdr.s_scnptr > 0) {
      unsigned int buf[256], chkbuf[256];
      register int cnt;
      register int addr;
      register int i,n;

      ldsseek (ldptr, sec_no);
      cnt = secthdr.s_size;
      addr = secthdr.s_paddr;
      while (cnt!=0) {
	if ((n=cnt) > 1024)
	  n = 1024;
	FREAD(buf,4,n>>2,ldptr);
	reverse(buf,n);
	for (i=0; i<(n>>2); i++) {
#ifdef	DEBUG
	  fprintf (stderr, "0x%x: 0x%x\n",
		   addr+(i<<2), buf[i]);
#endif
	  chkbuf[i] = buf[i];
	}
	if ((i=lseek(dev,(int)addr,0)) != addr) {
	  fprintf(stderr, "lseek: 0x%x\n",i);
	  ldclose(ldptr);
	  return -1;
	}
	if ((i=write(dev,buf,n)) != n) {
	  perror("dc_ld write error");
	  ldclose(ldptr);
	  return(-1) ;
	}
	if ((i=lseek(dev,(int)addr,0)) != addr) {
	  fprintf(stderr, "lseek: 0x%x\n",i);
	  ldclose(ldptr);
	  return -1;
	}
	for (i=0; i<(n>>2); i++)
	  chkbuf[i] = 0x5555AAAA;
	if ((i=read(dev,chkbuf,n)) != n) {
	  perror("dc_ld read error");
	  ldclose(ldptr);
	  return(-1) ;
	}
	for (i=0; i<(n>>2); i++) {
	  if (buf[i] != chkbuf[i])
	    fprintf (stderr, "dcld read check failed, addr 0x%x: is 0x%x should be 0x%x\n",
		     addr+(i<<2), chkbuf[i], buf[i]);
	}
	cnt -= n;
	addr += n;
      }

    } else {			/* HANDLES ".BSS"-type SEGMENTS */
      unsigned int buf[256];
      register int n, cnt = secthdr.s_size;
      register int addr = secthdr.s_paddr;

      for(n=0; n<256; buf[n++]=0);

      while (cnt != 0) {
	if ((n=cnt) > 1024)
	  n = 1024;
	if ((i=lseek(dev,(int)addr,0)) != addr) {
	  fprintf(stderr, "lseek: 0x%x\n",i);
	  ldclose(ldptr);
	  return -1;
	}
	if ((i=write(dev,buf,n)) != n) {
	  perror("dc_ld write error");
	  ldclose(ldptr);
	  return(-1) ;
	}
	if ((i=lseek(dev,(int)addr,0)) != addr) {
	  fprintf(stderr, "lseek: 0x%x\n",i);
	  ldclose(ldptr);
	  return -1;
	}
	if ((i=read(dev,buf,n)) != n) {
	  perror("dc_ld read error");
	  ldclose(ldptr);
	  return(-1) ;
	}
	for (i=0; i<(n>>2); i++)
	  if (buf[i] != 0)
	    fprintf (stderr, "dcld read check failed, addr 0x%x: is 0x%x should be 0\n",
		     addr+(i>>2), buf[i]);
	cnt -= n;
	addr += n;
      }
    }
  }
  if(!ldaclose (ldptr))
    fprintf(stderr, "Problems doing ldaclose() in dcld()\n");
  return 0;
#else
  fprintf(stderr,"dcld  called, filename: %s\n",filename);
  return -1;
#endif
}

dcopen(filename)
     char *filename;
{
  struct stat stbuf;
  int dsp, fdesc;

  if (stat(filename, &stbuf) != 0) {
    fprintf(stderr,"%s\n",filename);
    perror ("dcopen stat");
    return(-2);
  }

  if (!(stbuf.st_mode & S_IFCHR)) {
    fprintf (stderr, "?dcopen: not a dsp?\n");
    return(-3);
  }

  if ((dsp = open(filename, 2)) < 0) {
    perror("dcopen(): couldn't open dsp\n");
    return(-4);
  }

  return(dsp);
}

unsigned short dcgets(dsp, reg)
     int dsp, reg;
{
#if defined(DS3100) || defined(APOLLO_68K)
  return;
#else
  struct ioctlio dcmd;

  dcmd.devreg = reg;
  if (ioctl(dsp, DC_GETDREG, &dcmd) != 0) {
    perror("dcgets ioctl failed");
    exit(5);
  }
  return dcmd.data;
#endif
}

unsigned short dcputs(dsp, reg, value)
     int dsp, reg, value;
{
#if defined(DS3100) || defined(APOLLO_68K)
  return;
#else
  struct ioctlio dcmd;

  dcmd.devreg = reg;
  dcmd.data = value;
  if (ioctl(dsp, DC_SETDREG, &dcmd) != 0) {
    perror("dcputs ioctl failed");
    exit(5);
  }
#endif
}

unsigned short dcbgets(dsp, reg)
     int dsp, reg;
{
#if defined(DS3100) || defined(APOLLO_68K)
  return;
#else
  struct ioctlio dcmd;

  dcmd.devreg = reg;
  if (ioctl(dsp, DC_GETBREG, &dcmd) != 0) {
    perror("dcbgets ioctl failed");
    exit(5);
  }
  return dcmd.data;
#endif
}

unsigned short dcbputs(dsp, reg, value)
     int dsp, reg, value;
{
#if defined(DS3100) || defined(APOLLO_68K)
  return;
#else
  struct ioctlio dcmd;

  dcmd.devreg = reg;
  dcmd.data = value;
  if (ioctl(dsp, DC_SETBREG, &dcmd) != 0) {
    perror("dcbputs ioctl failed");
    exit(5);
  }
#endif
}

dc32wr(dsp, a, d)	/* write a 32b value to memory through the PIO */
     int dsp;
     int a, d;
{
#if defined(DS3100) || defined(APOLLO_68K)
  return;
#else
  int pcrl = dcgets(dsp, DC_PIO_PCRL);
  int pcrh = dcgets(dsp, DC_PIO_PCRH);
  int tmp = DC_PCRL_I16 | (pcrl & DC_PCRL_RUN);