text: /*-
   * Copyright (c) 2012 Ruslan Bukin <br@bsdpad.com>
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in the
   *    documentation and/or other materials provided with the distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   */
  
  /*
   * RME HDSPe driver for FreeBSD (pcm-part).
   * Supported cards: AIO, RayDAT.
   */
  
  #include <dev/sound/pcm/sound.h>
  #include <dev/sound/pci/hdspe.h>
  #include <dev/sound/chip.h>
  
  #include <dev/pci/pcireg.h>
  #include <dev/pci/pcivar.h>
  
  #include <mixer_if.h>
  
  SND_DECLARE_FILE("$FreeBSD: soc2013/dpl/head/sys/dev/sound/pci/hdspe-pcm.c 242241 2012-09-30 09:21:10Z kevlo $");
  
  struct hdspe_latency {
  	uint32_t n;
  	uint32_t period;
  	float ms;
  };
  
  static struct hdspe_latency latency_map[] = {
  	{ 7,   32, 0.7 },
  	{ 0,   64, 1.5 },
  	{ 1,  128,   3 },
  	{ 2,  256,   6 },
  	{ 3,  512,  12 },
  	{ 4, 1024,  23 },
  	{ 5, 2048,  46 },
  	{ 6, 4096,  93 },
  
  	{ 0,    0,   0 },
  };
  
  struct hdspe_rate {
  	uint32_t speed;
  	uint32_t reg;
  };
  
  static struct hdspe_rate rate_map[] = {
  	{  32000, (HDSPE_FREQ_32000) },
  	{  44100, (HDSPE_FREQ_44100) },
  	{  48000, (HDSPE_FREQ_48000) },
  	{  64000, (HDSPE_FREQ_32000 | HDSPE_FREQ_DOUBLE) },
  	{  88200, (HDSPE_FREQ_44100 | HDSPE_FREQ_DOUBLE) },
  	{  96000, (HDSPE_FREQ_48000 | HDSPE_FREQ_DOUBLE) },
  	{ 128000, (HDSPE_FREQ_32000 | HDSPE_FREQ_QUAD)   },
  	{ 176400, (HDSPE_FREQ_44100 | HDSPE_FREQ_QUAD)   },
  	{ 192000, (HDSPE_FREQ_48000 | HDSPE_FREQ_QUAD)   },
  
  	{ 0, 0 },
  };
  
  
  static int
  hdspe_hw_mixer(struct sc_chinfo *ch, unsigned int dst,
      unsigned int src, unsigned short data)
  {
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	int offs = 0;
  
  	if (ch->dir == PCMDIR_PLAY)
  		offs = 64;
  
  	hdspe_write_4(sc, HDSPE_MIXER_BASE +
  	    ((offs + src + 128 * dst) * sizeof(uint32_t)),
  	    data & 0xFFFF);
  
  	return 0;
  };
  
  static int
  hdspechan_setgain(struct sc_chinfo *ch)
  {
  
  	hdspe_hw_mixer(ch, ch->lslot, ch->lslot,
  	    ch->lvol * HDSPE_MAX_GAIN / 100);
  	hdspe_hw_mixer(ch, ch->rslot, ch->rslot,
  	    ch->rvol * HDSPE_MAX_GAIN / 100);
  
  	return 0;
  }
  
  static int
  hdspemixer_init(struct snd_mixer *m)
  {
  	struct sc_pcminfo *scp = mix_getdevinfo(m);
  	struct sc_info *sc = scp->sc;
  	int mask;
  
  	if (sc == NULL)
  		return -1;
  
  	mask = SOUND_MASK_PCM;
  
  	if (scp->hc->play)
  		mask |= SOUND_MASK_VOLUME;
  
  	if (scp->hc->rec)
  		mask |= SOUND_MASK_RECLEV;
  
  	snd_mtxlock(sc->lock);
  	pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
  	mix_setdevs(m, mask);
  	snd_mtxunlock(sc->lock);
  
  	return 0;
  }
  
  static int
  hdspemixer_set(struct snd_mixer *m, unsigned dev,
      unsigned left, unsigned right)
  {
  	struct sc_pcminfo *scp = mix_getdevinfo(m);
  	struct sc_chinfo *ch;
  	int i;
  
  #if 0
  	device_printf(scp->dev, "hdspemixer_set() %d %d\n",
  	    left,right);
  #endif
  
  	for (i = 0; i < scp->chnum; i++) {
  		ch = &scp->chan[i];
  		if ((dev == SOUND_MIXER_VOLUME && ch->dir == PCMDIR_PLAY) ||
  		    (dev == SOUND_MIXER_RECLEV && ch->dir == PCMDIR_REC)) {
  			ch->lvol = left;
  			ch->rvol = right;
  			if (ch->run)
  				hdspechan_setgain(ch);
  		}
  	}
  
  	return 0;
  }
  
  static kobj_method_t hdspemixer_methods[] = {
  	KOBJMETHOD(mixer_init,      hdspemixer_init),
  	KOBJMETHOD(mixer_set,       hdspemixer_set),
  	KOBJMETHOD_END
  };
  MIXER_DECLARE(hdspemixer);
  
  static void
  hdspechan_enable(struct sc_chinfo *ch, int value)
  {
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	int reg;
  
  	if (ch->dir == PCMDIR_PLAY)
  		reg = HDSPE_OUT_ENABLE_BASE;
  	else
  		reg = HDSPE_IN_ENABLE_BASE;
  
  	ch->run = value;
  
  	hdspe_write_1(sc, reg + (4 * ch->lslot), value);
  	hdspe_write_1(sc, reg + (4 * ch->rslot), value);
  }
  
  static int
  hdspe_running(struct sc_info *sc)
  {
  	struct sc_pcminfo *scp;
  	struct sc_chinfo *ch;
  	int i, j, devcount, err;
  	device_t *devlist;
  
  	if ((err = device_get_children(sc->dev, &devlist, &devcount)) != 0)
  		goto bad;
  
  	for (i = 0; i < devcount; i++) {
  		scp = device_get_ivars(devlist[i]);
  		for (j = 0; j < scp->chnum; j++) {
  			ch = &scp->chan[j];
  			if (ch->run)
  				goto bad;
  		}
  	}
  
  	free(devlist, M_TEMP);
  	return 0;
  bad:
  
  #if 0
  	device_printf(sc->dev,"hdspe is running\n");
  #endif
  
  	free(devlist, M_TEMP);
  	return 1;
  }
  
  static void
  hdspe_start_audio(struct sc_info *sc)
  {
  
  	sc->ctrl_register |= (HDSPE_AUDIO_INT_ENABLE | HDSPE_ENABLE);
  	hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
  }
  
  static void
  hdspe_stop_audio(struct sc_info *sc)
  {
  
  	if (hdspe_running(sc) == 1)
  		return;
  
  	sc->ctrl_register &= ~(HDSPE_AUDIO_INT_ENABLE | HDSPE_ENABLE);
  	hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
  }
  
  /* Multiplex / demultiplex: 2.0 <-> 2 x 1.0. */
  static void
  buffer_copy(struct sc_chinfo *ch)
  {
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	int length,src,dst;
  	int ssize, dsize;
  	int i;
  
  	length = sndbuf_getready(ch->buffer) /
  	    (4 /* Bytes per sample. */ * 2 /* channels */);
  
  	if (ch->dir == PCMDIR_PLAY) {
  		src = sndbuf_getreadyptr(ch->buffer);
  	} else {
  		src = sndbuf_getfreeptr(ch->buffer);
  	}
  
  	src /= 4; /* Bytes per sample. */
  	dst = src / 2; /* Destination buffer twice smaller. */
  
  	ssize = ch->size / 4;
  	dsize = ch->size / 8;
  
  	/*
  	 * Use two fragment buffer to avoid sound clipping.
  	 */
  
  	for (i = 0; i < sc->period * 2 /* fragments */; i++) {
  		if (ch->dir == PCMDIR_PLAY) {
  			sc->pbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->lslot] =
  			    ch->data[src];
  			sc->pbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->rslot] =
  			    ch->data[src + 1];
  
  		} else {
  			ch->data[src] =
  			    sc->rbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->lslot];
  			ch->data[src+1] =
  			    sc->rbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->rslot];
  		}
  
  		dst+=1;
  		dst %= dsize;
  		src+=2;
  		src %= ssize;
  	}
  }
  
  static int
  clean(struct sc_chinfo *ch){
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	uint32_t *buf = sc->rbuf;
  
  	if (ch->dir == PCMDIR_PLAY) {
  		buf = sc->pbuf;
  	}
  
  	bzero(buf + HDSPE_CHANBUF_SAMPLES * ch->lslot, HDSPE_CHANBUF_SIZE);
  	bzero(buf + HDSPE_CHANBUF_SAMPLES * ch->rslot, HDSPE_CHANBUF_SIZE);
  
  	return 0;
  }
  
  
  /* Channel interface. */
  static void *
  hdspechan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
                 struct pcm_channel *c, int dir)
  {
  	struct sc_pcminfo *scp = devinfo;
  	struct sc_info *sc = scp->sc;
  	struct sc_chinfo *ch;
  	int num;
  
  	snd_mtxlock(sc->lock);
  	num = scp->chnum;
  
  	ch = &scp->chan[num];
  	ch->lslot = scp->hc->left;
  	ch->rslot = scp->hc->right;
  	ch->run = 0;
  	ch->lvol = 0;
  	ch->rvol = 0;
  
  	ch->size = HDSPE_CHANBUF_SIZE * 2 /* slots */;
  	ch->data = malloc(ch->size, M_HDSPE, M_NOWAIT);
  
  	ch->buffer = b;
  	ch->channel = c;
  	ch->parent = scp;
  
  	ch->dir = dir;
  
  	snd_mtxunlock(sc->lock);
  
  	if (sndbuf_setup(ch->buffer, ch->data, ch->size) != 0) {
  		device_printf(scp->dev, "Can't setup sndbuf.\n");
  		return NULL;
  	}
  
  	return ch;
  }
  
  static int
  hdspechan_trigger(kobj_t obj, void *data, int go)
  {
  	struct sc_chinfo *ch = data;
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  
  	snd_mtxlock(sc->lock);
  	switch (go) {
  	case PCMTRIG_START:
  #if 0
  		device_printf(scp->dev, "hdspechan_trigger(): start\n");
  #endif
  		hdspechan_enable(ch, 1);
  		hdspechan_setgain(ch);
  		hdspe_start_audio(sc);
  		break;
  
  	case PCMTRIG_STOP:
  	case PCMTRIG_ABORT:
  #if 0
  		device_printf(scp->dev, "hdspechan_trigger(): stop or abort\n");
  #endif
  		clean(ch);
  		hdspechan_enable(ch, 0);
  		hdspe_stop_audio(sc);
  		break;
  
  	case PCMTRIG_EMLDMAWR:
  	case PCMTRIG_EMLDMARD:
  		if(ch->run)
  			buffer_copy(ch);
  		break;
  	}
  
  	snd_mtxunlock(sc->lock);
  
  	return 0;
  }
  
  static uint32_t
  hdspechan_getptr(kobj_t obj, void *data)
  {
  	struct sc_chinfo *ch = data;
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	uint32_t ret, pos;
  
  	snd_mtxlock(sc->lock);
  	ret = hdspe_read_2(sc, HDSPE_STATUS_REG);
  	snd_mtxunlock(sc->lock);
  
  	pos = ret & HDSPE_BUF_POSITION_MASK;
  	pos *= 2; /* Hardbuf twice bigger. */
  
  	return pos;
  }
  
  static int
  hdspechan_free(kobj_t obj, void *data)
  {
  	struct sc_chinfo *ch = data;
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  
  #if 0
  	device_printf(scp->dev, "hdspechan_free()\n");
  #endif
  	snd_mtxlock(sc->lock);
  	if (ch->data != NULL) {
  		free(ch->data, M_HDSPE);
  		ch->data = NULL;
  	}
  	snd_mtxunlock(sc->lock);
  
  	return 0;
  }
  
  static int
  hdspechan_setformat(kobj_t obj, void *data, uint32_t format)
  {
  	struct sc_chinfo *ch = data;
  
  #if 0
  	struct sc_pcminfo *scp = ch->parent;
  	device_printf(scp->dev, "hdspechan_setformat(%d)\n", format);
  #endif
  
  	ch->format = format;
  
  	return 0;
  }
  
  static uint32_t
  hdspechan_setspeed(kobj_t obj, void *data, uint32_t speed)
  {
  	struct sc_chinfo *ch = data;
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	struct hdspe_rate *hr = NULL;
  	long long period;
  	int threshold;
  	int i;
  
  #if 0
  	device_printf(scp->dev, "hdspechan_setspeed(%d)\n", speed);
  #endif
  
  	if (hdspe_running(sc) == 1)
  		goto end;
  
  	/* First look for equal frequency. */
  	for (i = 0; rate_map[i].speed != 0; i++) {
  		if (rate_map[i].speed == speed)
  			hr = &rate_map[i];
  	}
  
  	/* If no match, just find nearest. */
  	if (hr == NULL) {
  		for (i = 0; rate_map[i].speed != 0; i++) {
  			hr = &rate_map[i];
  			threshold = hr->speed + ((rate_map[i + 1].speed != 0) ?
  			    ((rate_map[i + 1].speed - hr->speed) >> 1) : 0);
  			if (speed < threshold)
  				break;
  		}
  	}
  
  	switch (sc->type) {
  	case RAYDAT:
  	case AIO:
  		period = HDSPE_FREQ_AIO;
  		break;
  	default:
  		/* Unsupported card. */
  		goto end;
  	}
  
  	/* Write frequency on the device. */
  	sc->ctrl_register &= ~HDSPE_FREQ_MASK;
  	sc->ctrl_register |= hr->reg;
  	hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
  
  	speed = hr->speed;
  	if (speed > 96000)
  		speed /= 4;
  	else if (speed > 48000)
  		speed /= 2;
  
  	/* Set DDS value. */
  	period /= speed;
  	hdspe_write_4(sc, HDSPE_FREQ_REG, period);
  
  	sc->speed = hr->speed;
  end:
  	return sc->speed;
  }
  
  static uint32_t
  hdspechan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
  {
  	struct sc_chinfo *ch = data;
  	struct sc_pcminfo *scp = ch->parent;
  	struct sc_info *sc = scp->sc;
  	struct hdspe_latency *hl = NULL;
  	int threshold;
  	int i;
  
  #if 0
  	device_printf(scp->dev, "hdspechan_setblocksize(%d)\n", blocksize);
  #endif
  
  	if (hdspe_running(sc) == 1)
  		goto end;
  
  	if (blocksize > HDSPE_LAT_BYTES_MAX)
  		blocksize = HDSPE_LAT_BYTES_MAX;
  	else if (blocksize < HDSPE_LAT_BYTES_MIN)
  		blocksize = HDSPE_LAT_BYTES_MIN;
  
  	blocksize /= 4 /* samples */;
  
  	/* First look for equal latency. */
  	for (i = 0; latency_map[i].period != 0; i++) {
  		if (latency_map[i].period == blocksize) {
  			hl = &latency_map[i];
  		}
  	}
  
  	/* If no match, just find nearest. */
  	if (hl == NULL) {
  		for (i = 0; latency_map[i].period != 0; i++) {
  			hl = &latency_map[i];
  			threshold = hl->period + ((latency_map[i + 1].period != 0) ?
  			    ((latency_map[i + 1].period - hl->period) >> 1) : 0);
  			if (blocksize < threshold)
  				break;
  		}
  	}
  
  	snd_mtxlock(sc->lock);
  	sc->ctrl_register &= ~HDSPE_LAT_MASK;
  	sc->ctrl_register |= hdspe_encode_latency(hl->n);
  	hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
  	sc->period = hl->period;
  	snd_mtxunlock(sc->lock);
  
  #if 0
  	device_printf(scp->dev, "New period=%d\n", sc->period);
  #endif
  
  	sndbuf_resize(ch->buffer, (HDSPE_CHANBUF_SIZE * 2) / (sc->period * 4),
  	    (sc->period * 4));
  end:
  	return sndbuf_getblksz(ch->buffer);
  }
  
  static uint32_t hdspe_rfmt[] = {
  	SND_FORMAT(AFMT_S32_LE, 2, 0),
  	0
  };
  
  static struct pcmchan_caps hdspe_rcaps = {32000, 192000, hdspe_rfmt, 0};
  
  static uint32_t hdspe_pfmt[] = {
  	SND_FORMAT(AFMT_S32_LE, 2, 0),
  	0
  };
  
  static struct pcmchan_caps hdspe_pcaps = {32000, 192000, hdspe_pfmt, 0};
  
  static struct pcmchan_caps *
  hdspechan_getcaps(kobj_t obj, void *data)
  {
  	struct sc_chinfo *ch = data;
  
  #if 0
  	struct sc_pcminfo *scl = ch->parent;
  	device_printf(scp->dev, "hdspechan_getcaps()\n");
  #endif
  
  	return (ch->dir == PCMDIR_PLAY) ?
  	    &hdspe_pcaps : &hdspe_rcaps;
  }
  
  static kobj_method_t hdspechan_methods[] = {
  	KOBJMETHOD(channel_init,         hdspechan_init),
  	KOBJMETHOD(channel_free,         hdspechan_free),
  	KOBJMETHOD(channel_setformat,    hdspechan_setformat),
  	KOBJMETHOD(channel_setspeed,     hdspechan_setspeed),
  	KOBJMETHOD(channel_setblocksize, hdspechan_setblocksize),
  	KOBJMETHOD(channel_trigger,      hdspechan_trigger),
  	KOBJMETHOD(channel_getptr,       hdspechan_getptr),
  	KOBJMETHOD(channel_getcaps,      hdspechan_getcaps),
  	KOBJMETHOD_END
  };
  CHANNEL_DECLARE(hdspechan);
  
  
  static int
  hdspe_pcm_probe(device_t dev)
  {
  
  #if 0
  	device_printf(dev,"hdspe_pcm_probe()\n");
  #endif
  
  	return 0;
  }
  
  static uint32_t
  hdspe_pcm_intr(struct sc_pcminfo *scp) {
  	struct sc_chinfo *ch;
  	struct sc_info *sc = scp->sc;
  	int i;
  
  	for (i = 0; i < scp->chnum; i++) {
  		ch = &scp->chan[i];
  		snd_mtxunlock(sc->lock);
  		chn_intr(ch->channel);
  		snd_mtxlock(sc->lock);
  	}
  
  	return 0;
  }
  
  static int
  hdspe_pcm_attach(device_t dev)
  {
  	struct sc_pcminfo *scp;
  	char status[SND_STATUSLEN];
  	char desc[64];
  	int i, err;
  
  	scp = device_get_ivars(dev);
  	scp->ih = &hdspe_pcm_intr;
  
  	bzero(desc, sizeof(desc));
  	snprintf(desc, sizeof(desc), "HDSPe AIO [%s]", scp->hc->descr);
  	device_set_desc_copy(dev, desc);
  
  	/*
  	 * We don't register interrupt handler with snd_setup_intr
  	 * in pcm device. Mark pcm device as MPSAFE manually.
  	 */
  	pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
  
  	err = pcm_register(dev, scp, scp->hc->play, scp->hc->rec);
  	if (err) {
  		device_printf(dev, "Can't register pcm.\n");
  		return ENXIO;
  	}
  
  	scp->chnum = 0;
  	for (i = 0; i < scp->hc->play; i++) {
  		pcm_addchan(dev, PCMDIR_PLAY, &hdspechan_class, scp);
  		scp->chnum++;
  	}
  
  	for (i = 0; i < scp->hc->rec; i++) {
  		pcm_addchan(dev, PCMDIR_REC, &hdspechan_class, scp);
  		scp->chnum++;
  	}
  
  	snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld %s",
  	    rman_get_start(scp->sc->cs),
  	    rman_get_start(scp->sc->irq),
  	    PCM_KLDSTRING(snd_hdspe));
  	pcm_setstatus(dev, status);
  
  	mixer_init(dev, &hdspemixer_class, scp);
  
  	return 0;
  }
  
  static int
  hdspe_pcm_detach(device_t dev)
  {
  	int err;
  
  	err = pcm_unregister(dev);
  	if (err) {
  		device_printf(dev, "Can't unregister device.\n");
  		return err;
  	}
  
  	return 0;
  }
  
  static device_method_t hdspe_pcm_methods[] = {
  	DEVMETHOD(device_probe,     hdspe_pcm_probe),
  	DEVMETHOD(device_attach,    hdspe_pcm_attach),
  	DEVMETHOD(device_detach,    hdspe_pcm_detach),
  	{ 0, 0 }
  };
  
  static driver_t hdspe_pcm_driver = {
  	"pcm",
  	hdspe_pcm_methods,
  	PCM_SOFTC_SIZE,
  };
  
  DRIVER_MODULE(snd_hdspe_pcm, hdspe, hdspe_pcm_driver, pcm_devclass, 0, 0);
  MODULE_DEPEND(snd_hdspe, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
  MODULE_VERSION(snd_hdspe, 1);
  