ddutils.c

speech signal process tools

/* ddutile.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.
 */
 

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


typedef unsigned long ulong;

int dsp32c_sm = -1;
int dsp32c_io = -1;
int dsp32c[6] = {-1, -1, -1, -1, -1, -1};
char	*DSP_SharedMemory=NULL;	/* Ptr to base of shared mem. */
char    *DSP_io=NULL;	/* pointer to emeory-mapped I/O registers */

reverse(buf,n)			/* little endian to big endian */
     unsigned long *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;
{
#ifndef TESTING_ONLY
  register LDFILE		*ldptr;
  FILHDR			filhdr;
  SCNHDR			secthdr;
  register unsigned	sec_no;
  register long		addr,
  sect_end;
  register long		size = 0L;
  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 (%ld), section number %d",
	      size, sec_no);
      ldclose(ldptr);
      return(-1);
    }
    if (secthdr.s_name[0] == '\0')
      continue;			/* <== <== */
    if (secthdr.s_scnptr > 0) {
      unsigned long 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,(long)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,(long)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 long 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,(long)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,(long)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;
      }
    }
  }
  ldaclose (ldptr);
  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;
{
  struct ioctlio dcmd;

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

unsigned short dcputs(dsp, reg, value)
     int dsp, reg, value;
{
  struct ioctlio dcmd;

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

unsigned short dcbgets(dsp, reg)
     int dsp, reg;
{
  struct ioctlio dcmd;

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

unsigned short dcbputs(dsp, reg, value)
     int dsp, reg, value;
{
  struct ioctlio dcmd;

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

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

  dcputs(dsp, DC_PIO_PCRL, tmp);
  dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE);
  dcputs(dsp, DC_PIO_PARE, a >> 16);
  dcputs(dsp, DC_PIO_PARL, a);
  dcputs(dsp, DC_PIO_PARH, a >> 8);
  dcputs(dsp, DC_PIO_PCRL, tmp | DC_PCRL_DMA);
  dcputs(dsp, DC_PIO_PDR2L, d & 0xff);
  dcputs(dsp, DC_PIO_PDR2H, (d >> 8) & 0xff);
  dcputs(dsp, DC_PIO_PDRL, d>>16);
  dcputs(dsp, DC_PIO_PDRH, d>>24);
  while (dcgets(dsp, DC_PIO_PCRL) & DC_PCRL_PDF);
  dcputs(dsp, DC_PIO_PCRL, pcrl);
  dcputs(dsp, DC_PIO_PCRH, pcrh);
}

unsigned long dc32rd(dsp, a)		/* read a 32b value through the PIO */
     int dsp;
     register unsigned long a;
{
  register unsigned long dll, dlh, dhl, dhh;
  int pcrl = dcgets(dsp, DC_PIO_PCRL);
  int pcrh = dcgets(dsp, DC_PIO_PCRH);
  int tmp = DC_PCRL_I16 | (pcrl & DC_PCRL_RUN);

  dcputs(dsp, DC_PIO_PCRL, tmp);
  dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE);
  if (dcgets(dsp, DC_PIO_PCRL) & DC_PCRL_PDF)
    dcgets(dsp, DC_PIO_PDRH);
  dcputs(dsp, DC_PIO_PCRL, tmp | DC_PCRL_DMA);
  dcputs(dsp, DC_PIO_PARE, a >> 16);
  dcputs(dsp, DC_PIO_PARL, a & 0xff);
  dcputs(dsp, DC_PIO_PARH, (a>>8) & 0xff);
  while (!(dcgets(dsp, DC_PIO_PCRL) & DC_PCRL_PDF));
  dcputs(dsp, DC_PIO_PCRL, tmp);
  dll = dcgets(dsp, DC_PIO_PDR2L) & 0xff;
  dlh = dcgets(dsp, DC_PIO_PDR2H) & 0xff;
  dhl = dcgets(dsp, DC_PIO_PDRL) & 0xff;
  dhh = dcgets(dsp, DC_PIO_PDRH) & 0xff;
  dcputs(dsp, DC_PIO_PCRL, pcrl);
  dcputs(dsp, DC_PIO_PCRH, pcrh);
  return((((((dhh<<8) | dhl)<<8) | dlh)<<8) | dll);
}

dcrun(dsp)
     int dsp;
{
  dcputs(dsp, DC_PIO_PCRL, DC_PCRL_MODE); /* halt it */
  dcputs(dsp, DC_PIO_PCRL, DC_PCRL_RUN); /* start it */
  dcputs(dsp, DC_PIO_PCRL, DC_PCRL_MODE | DC_PCRL_RUN);	/* set the mode */
  dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE);
}

dcinit(dsp, run)
     register DSP32C *dsp;
     int run;
{
  int tmp;

  dcputs(dsp, DC_PIO_PCRL, DC_PCRL_I16);
  dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE);
  dc32wr(dsp, 0L, 0x200000);
  dc32wr(dsp, 4L, 0L);
  dc32wr(dsp, 8L, 0L);
  dcputs(dsp, DC_PIO_PCRL, DC_PCRL_RUN);
  dcputs(dsp, DC_PIO_PCRL, run | DC_PCRL_I16);
  dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE);
  dcgets(dsp, DC_PIO_PIRH);
  tmp = dcgets(dsp, DC_PIO_EMRH);
  dcputs(dsp, DC_PIO_EMRH, tmp & ~(DC_EMRI_NAN | DC_EMRI_DAU | DC_EMRI_ADR));
  tmp = dcgets(dsp, DC_PIO_EMRL);
  dcputs(dsp, DC_PIO_EMRL, tmp & ~(DC_EMRI_NAN | DC_EMRI_DAU | DC_EMRI_ADR));
  dcgets(dsp, DC_PIO_ESR);
  dcgets(dsp, DC_PIO_PDRH);
  dcputs(dsp, DC_PIO_PCRL, run | DC_PCRL_MODE);
  dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE);
}

extern char	*valloc();

char *dcmap(dsp, npages, offset)
     int dsp, npages, offset;
{
  char *page = (char*)0;
  int size = getpagesize() * npages;

  if (dsp <= 0) {
    fprintf(stderr, "?dcmap: invalid file descriptor?\n");
    return (char*) 0;
  }
  if ((page = valloc (size)) == (char*)0) {
    perror ("dcmap: couldn't allocate memory");
    return (char*)0;
  }
  if (mmap(page,size,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_FIXED,dsp,offset)
      == ((caddr_t) -1)) {
    perror("dcmap: mmap failed");
    free(page);
    return (char*) 0;
  }
  return (char*) page;
}

/*************************************************************************/
open_32c_io(dev)
     char *dev;
{
  if(! DSP_io) {
    if((dsp32c_io < 0) && ((dsp32c_io = dcopen(dev)) < 0)) {
      printf("Couldn't open register file %s\n",dev);
      return(FALSE);
    }
    if(!(DSP_io = (char*)dcmap(dsp32c_io,1,0))) {
      printf("I/O map failure: dsp32c_io=%d IO=%x\n",dsp32c_io,DSP_io);
      return(FALSE);
    }
  }
  return(TRUE);
}


/*************************************************************************/
open_32c_sm(dev)
  char *dev;
{
  if(! DSP_SharedMemory) {
    if((dsp32c_sm < 0) && ((dsp32c_sm = dcopen(dev)) < 0)) {
      printf("Couldn't open shared memory %s\n",dev);
      return(FALSE);
    }
    if(!(DSP_SharedMemory = (char*)dcmap(dsp32c_sm,0x100000/getpagesize(),0))) {
      printf("DRAM map failure: dsp32c_io=%d SM=%x\n",dsp32c_sm,
	     DSP_SharedMemory);
      return(FALSE);
    }
  }
  return(TRUE);
}

/*************************************************************************/
dcgets2(chip,reg)
     int chip, reg;
{
  if(open_32c_io("/dev/dc0io"))
    return((*(DSP_io + 0x41 + (reg<<1) + (chip * 0x20))) & 0xff);
  else
    return(0);
}

/*************************************************************************/
dcputs2(chip,reg,val)
     int chip, reg,val;
{
  unsigned char it = val & 0xff;

  if(open_32c_io("/dev/dc0io"))
    *(DSP_io + 0x41 + (reg<<1) + (chip * 0x20)) = it;
}


/*************************************************************************/
close_io_mem()
{
  if(dsp32c_sm >= 0) close(dsp32c_sm);
  if(dsp32c_io >= 0) close(dsp32c_io);
  dsp32c_io = dsp32c_sm = -1;
  DSP_SharedMemory = DSP_io = NULL;
}

/*************************************************************************/
close_dsp32cs()
{
  int chip;

  for(chip = 0; chip < 6; chip++) {
    if(dsp32c[chip] >= 0) close(dsp32c[chip]);
    dsp32c[chip] = -1;
  }
}

/*************************************************************************/
dsp_pir_wait(chip, dur, code)
     int chip, dur, code;
{
  int count = dur, rcode;

  if(dsp32c[chip] >= 0) {
    dcputs2(chip,DC_PIO_PIRL,code);
    dcputs2(chip,DC_PIO_PIRH,0);
    while(count--) {
      rcode = (char)(dcgets2(chip,DC_PIO_PIRL) & 0xff);
      dcgets2(chip,DC_PIO_PIRH);
      if(rcode == -code) {
	return(dur-count);
      }
    }
    printf("code:%x rcode:%x\n",code,rcode);
    return(dur);
  } else
    printf("DSP32c device is not open (dsp32c=%d)\n",dsp32c[chip]);
  return(dur);
}

/*************************************************************************/
dsp_wait(chip, dur, code)
     int chip, dur, code;
{
  int count = dur, rcode;

  if(dsp32c[chip] >= 0) {
    dcputs2(chip,DC_PIO_PDRL,code);
    dcputs2(chip,DC_PIO_PDRH,0);
    while(count--) {
      rcode = (char)(dcgets2(chip,DC_PIO_PDRL) & 0xff);
      dcgets2(chip,DC_PIO_PDRH);
      if(rcode == -code) {
	return(dur-count);
      }
    }
    printf("code:%x rcode:%x\n",code,rcode);
    return(dur);
  } else
    printf("DSP32c device is not open (dsp32c=%d)\n",dsp32c[chip]);
  return(dur);
}

/*************************************************************************/
init_dsp32cs()
{
  char dsname[200];
  int chip;

  for(chip = 0; chip < 3; chip++) {
    sprintf(dsname,"/dev/dc0%d",chip);
    if((dsp32c[chip] = dcopen(dsname)) < 0) {
      printf("Couldn't open %s",dsname);
      return(FALSE);
    }
    if (ioctl(dsp32c[chip], DC_RESET, (char*)NULL) != 0) {
      printf ("Couldn't reset %s in init_dsp32cs().\n",dsname);
      return(FALSE);
    }
    dcinit(dsp32c[chip], 0);
  }
  return(TRUE);
}