ddutils.c

speech signal process tools

  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);
#endif
}

unsigned int dc32rd(dsp, a)		/* read a 32b value through the PIO */
     int dsp;
     register unsigned int a;
{
#if defined(DS3100) || defined(APOLLO_68K)
  return;
#else
  register unsigned int 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);
#endif
}

dcrun(dsp)
     int dsp;
{
#if !defined(DS3100) && !defined(APOLLO_68K)
  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);
#endif
}

#ifndef USE_OLD_STUFF
/* Here is  the NEW way of doing initialization that, supposedly,
   clears any hung states on SURF. */
dcinit(dsp, run)
     register DSP32C *dsp;
     int run;
{
#if !defined(DS3100) && !defined(APOLLO_68K)
  ioctl(dsp, DC_INIT, (char*)NULL);
  if (run) {
    dcputs(dsp, DC_PIO_PCRL, 1 | DC_PCRL_MODE);	/* start the dsp */
    dcputs(dsp, DC_PIO_PCRL, 1 | DC_PCRL_MODE);	/* rewrite the other bits */
    dcputs(dsp, DC_PIO_PCRH, DC_PCRH_MODE); /* write pcrh */
  }
#endif
}
#else
dcinit(dsp, run)
     register DSP32C *dsp;
     int run;
{
  int tmp;
#if !defined(DS3100) && !defined(APOLLO_68K)

  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);
#endif
}
#endif

extern char	*valloc();

char *dcmap(dsp, npages, offset)
     int dsp, npages, offset;
{
#if !defined(SONY_RISC) && !defined(DS3100) && !defined(APOLLO_68K)
  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;
#else
  fprintf(stderr,"dcmap: shouldn't be called on this machine!\n");
#endif
}

/*************************************************************************/
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,SURF_SM_SIZE/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(DSP_io || open_32c_io(global_dc_device("io")))
    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(DSP_io || open_32c_io(global_dc_device("io")))
    *(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;
  if(DSP_SharedMemory) {
    int npages = SURF_SM_SIZE/getpagesize();
    munmap(DSP_SharedMemory, npages*getpagesize());
    free(DSP_SharedMemory);
  }
  if(DSP_io) {
    munmap(DSP_io,getpagesize());
    free(DSP_io);
  }
  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);
}

#ifndef USE_OLD_STUFF
/*************************************************************************/
init_dsp32cs()
{
#if !defined(DS3100) && !defined(APOLLO_68K)
  char dsname[200];
  int chip;

  for(chip = 0; chip < 3; chip++) {
    sprintf(dsname,"%s%d", global_dc_device(""), chip);
    if((dsp32c[chip] = dcopen(dsname)) < 0) {
      printf("Couldn't open %s",dsname);
      return(FALSE);
    }
  }
  /*
   *      SIO may be running. if we turn off dsps in 0-1-2 order, 
   *      dsp1 will still be sourcing data when dsp0 is reset 
   *      and SIO between dsp0 and dsp1 will hang
   */ 
  ioctl(dsp32c[1], DC_STOP); 
  ioctl(dsp32c[0], DC_STOP); 
  ioctl(dsp32c[2], DC_STOP);
  dcinit(dsp32c[1], 0);
  dcinit(dsp32c[0], 0);
  dcinit(dsp32c[2], 0);
  
  return(TRUE);
#endif
}
#else
/*************************************************************************/
init_dsp32cs()
{
#if !defined(DS3100) && !defined(APOLLO_68K)
  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);
#endif
}
#endif

#else

dcopen(){}
dcgets2(){}
dcgets(){}
dcinit(){}
close_dsp32cs(){}
close_io_mem(){}
dcld(){}
open_32c_io(){}
open_32c_sm(){}
dcrun(){}
dsp_wait(){}
char *dcmap(){}
init_dsp32cs(){}
dsp_pir_wait(){}
dcputs(){}
dcbgets(){}
dcbputs(){}
dc32wr(){}
dc32rd(){}
dcputs2(){}
char* global_dc_device(){}
dsp32c_is_available() {}

#endif