/*
        Copyright 1999, Be Incorporated.   All Rights Reserved.
        This file may be used under the terms of the Be Sample Code License.
*/
#include <string.h>

#include <ByteOrder.h>
#include <MediaDefs.h>

#include "cm_private.h"
#include "sound.h"

#include <KernelExport.h>

extern int sprintf(char *, const char *, ...);


extern void dump_card(cmedia_pci_dev * card);

// Buffer header for audio server from BeOS R3 MediaDefs.h

typedef struct audio_buffer_header {
        int32           buffer_number;
        int32           subscriber_count;
        bigtime_t       time;
        int32           reserved_1;
        int32           reserved_2;
        bigtime_t       sample_clock;
} audio_buffer_header;

#if !defined(OLDAPI)
 #if DEBUG
  #define OLDAPI(x) dprintf x
 #else
  #define OLDAPI(x)
 #endif
#endif

#if DEBUG
int32 int_cnt;
int32 put_cnt;
bigtime_t the_time;
#endif

#if 0
/* early Intel kernels forgot to export these functions */
#undef B_HOST_TO_LENDIAN_FLOAT
#undef B_HOST_TO_BENDIAN_FLOAT
#undef B_LENDIAN_TO_HOST_FLOAT
#undef B_BENDIAN_TO_HOST_FLOAT

static float
_swap_float_(float x)
{
        uint32 temp1 = *(uint32*)&x;
        uint32 temp2 = ((temp1>>24)|((temp1>>8)&0xff00)|((temp1<<8)&0xff0000)|
                                        (temp1<<24));
        return *(float *)&temp2;
}

#if B_HOST_IS_BENDIAN
#define B_HOST_TO_LENDIAN_FLOAT(x) _swap_float_(x)
#define B_HOST_TO_BENDIAN_FLOAT(x) ((float)(x))
#define B_LENDIAN_TO_HOST_FLOAT(x) _swap_float_(x)
#define B_BENDIAN_TO_HOST_FLOAT(x) ((float)(x))
#else
#define B_HOST_TO_LENDIAN_FLOAT(x) ((float)(x))
#define B_HOST_TO_BENDIAN_FLOAT(x) _swap_float_(x)
#define B_LENDIAN_TO_HOST_FLOAT(x) ((float)(x))
#define B_BENDIAN_TO_HOST_FLOAT(x) _swap_float_(x)
#endif

#endif


static status_t pcm_open(const char *name, uint32 flags, void **cookie);
static status_t pcm_close(void *cookie);
static status_t pcm_free(void *cookie);
static status_t pcm_control(void *cookie, uint32 op, void *data, size_t len);
static status_t pcm_read(void *cookie, off_t pos, void *data, size_t *len);
static status_t pcm_write(void *cookie, off_t pos, const void *data, size_t *len);
//static status_t pcm_writev(void *cookie, off_t pos, const iovec *vec, size_t count, size_t *len); /* */

device_hooks pcm_hooks = {
    &pcm_open,
    &pcm_close,
    &pcm_free,
    &pcm_control,
    &pcm_read,
    &pcm_write,
    NULL,                       /* select */
    NULL,                       /* deselect */
    NULL,                       /* readv */
        NULL    // &pcm_writev          /* writev */
};

static pcm_cfg default_pcm = {
        44100.0,        /* sample rate */
        2,                      /* channels */
        0x2,            /* format */
#if B_HOST_IS_BENDIAN
        1,                      /* endian (big) */
#else
        0,                      /* endian (little) */
#endif
        0,                      /* header size */
        PLAYBACK_BUF_SIZE,      /* these are currently hard-coded */
        RECORD_BUF_SIZE         /* and cannot be changed without re-compile */
};


#if 0

typedef struct {
        uint8 control;
        uint8 imask;
        uint8 regs[0x2e];
} chip_state;

static void
save_state(
        pcm_dev * port,
        chip_state * state)
{
        int ix;
        state->control = get_direct(port->card, 0);
        state->imask = get_direct(port->card, 1);
        for (ix=0; ix<0x0e; ix++) {
                if (ix != 0x28 && ix != 0x29 && ix != 0x1a && ix != 0x1b) {
                        state->regs[ix] = get_indirect(port->card, ix+0x30);
                }
        }
}


static void
restore_state(
        pcm_dev * port,
        const chip_state * state)
{
        int ix;
        set_direct(port->card, 0, state->control, 0xff);
        for (ix=0; ix<0x0e; ix++) {
                if (ix != 0x28 && ix != 0x29 && ix != 0x1a && ix != 0x1b) {
                        set_indirect(port->card, ix, state->regs[ix]+0x30, 0xff);
                }
        }
        set_direct(port->card, 1, state->imask, 0xff);
}


static void
reset_chip(
        pcm_dev * port)
{
        set_direct(port->card, 0x1b, 0x40, 0x40);
        snooze(2);
        set_direct(port->card, 0x1b, 0x00, 0x40);
}

#endif


static void
stop_dma(
        pcm_dev * port)
{
        set_direct(port->card, 0x24, 0x40, 0x40);       // mute wave stream
        set_direct(port->card, 0x02, 0, 0x03);          // stop both ch0 and ch1

        set_direct(port->card, 0x02, 0x0c, 0x0c);       // reset both ch0 and ch1
        set_direct(port->card, 0x02, 0, 0x0c);
        ddprintf(("cmedia_pci: DMA stopped\n"));
}


static void
start_dma(
        pcm_dev * port)
{
        int     sample_size = 1;

        /* start out with a clean slate */

        KTRACE();
        ddprintf(("cmedia_pci: start_dma()\n"));
        if (port->config.format == 0x11) {
                memset((void*)port->card->low_mem, 0x80, port->config.play_buf_size +
                        port->config.rec_buf_size);
        }
        else {
                memset((void *)port->card->low_mem, 0, port->config.play_buf_size +
                        port->config.rec_buf_size);
        }

        port->wr_cur = port->wr_2;
        port->wr_silence = port->config.play_buf_size;
        port->was_written = 0;
        port->rd_cur = port->rd_2;
        port->was_read = port->config.rec_buf_size/2; /* how much has been read */
        port->wr_total = 0;
        port->rd_total = 0;

        /* we split the available low memory buffer in a small chunk */
        /* for playback, and a large chunk for recording. Then we split */
        /* each of those in half for double-buffering. While the DMA */
        /* just runs the entire range of the buffer, wrapping around when */
        /* done, the count register is set up to generate interrupt after */
        /* each half of the buffer. Because of latency requirements, we */
        /* will get 187 interrupts a second from playback, and 94 interrupts */
        /* a second from recording, at 48 kHz sampling rate, when buffers */
        /* are 2048 for playback and 4096 for record. */

        ddprintf(("play_buf_size %lx   rec_buf_size %lx\n",
                port->config.play_buf_size/2, port->config.rec_buf_size/2));

        PCI_IO_WR(port->dma_c, ((uint32)port->card->low_phys+
                port->config.play_buf_size)&0xff);
        PCI_IO_WR(port->dma_c+1, (((uint32)port->card->low_phys+
                port->config.play_buf_size)>>8)&0xff);
        PCI_IO_WR(port->dma_c+2, (((uint32)port->card->low_phys+
                port->config.play_buf_size)>>16)&0xff);
        PCI_IO_WR(port->dma_c+3, 0);
        /* if this is a 16 bit channel, divide transfer count in 2 */
        if (port->config.format != 0x11)
                sample_size *= 2;
        /* if this is a stereo channel, divide transfer count in 2 */
        if (port->config.channels == 2)
                sample_size *= 2;
        PCI_IO_WR(port->dma_c+4, (port->config.rec_buf_size/sample_size-1)&0xff);
        PCI_IO_WR(port->dma_c+5, ((port->config.rec_buf_size/sample_size-1)>>8)&0xff);
        PCI_IO_WR(port->dma_c+6, (port->rd_size/sample_size-1)&0xff);
        PCI_IO_WR(port->dma_c+7, ((port->rd_size/sample_size-1)>>8)&0xff);

        PCI_IO_WR(port->dma_a, ((uint32)port->card->low_phys)&0xff);
        PCI_IO_WR(port->dma_a+1, ((uint32)port->card->low_phys>>8)&0xff);
        PCI_IO_WR(port->dma_a+2, ((uint32)port->card->low_phys>>16)&0xff);
        PCI_IO_WR(port->dma_a+3, 0);
        PCI_IO_WR(port->dma_a+4, (port->config.play_buf_size/sample_size-1)&0xff);
        PCI_IO_WR(port->dma_a+5, ((port->config.play_buf_size/sample_size-1)>>8)&0xff);
        PCI_IO_WR(port->dma_a+6, (port->wr_size/sample_size-1)&0xff);
        PCI_IO_WR(port->dma_a+7, ((port->wr_size/sample_size-1)>>8)&0xff);

/* here, we should mute the PCM output to avoid clicking */

        ddprintf(("cmedia_pci: DMA starts as %lx/%lx\n", port->config.format, port->open_mode));
        set_direct(port->card, 0x24, 0x00, 0x40);

/* enable ch0 as play, and ch1 as record */
        set_direct(port->card, 0, 0x02, 0x03);
        set_direct(port->card, 0x02, 0x03, 0x03);

/* here, we should snooze for 16 samples' time, then un-mute the PCM output */
        KTRACE();
}


static status_t
configure_pcm(
        pcm_dev * port,
        pcm_cfg * config,
        bool force)
{
        status_t err = B_OK;
        int m = 0, n = 0, r = 0;        /* parameters for the PLL sample rate synthesizer */
        int asr = -1;   /* alternate sample rate divisor */
        uint32 s;       /* size of buffer */

        ddprintf(("cmedia_pci: configure_pcm()\n"));

        /* check args */
        if (config->sample_rate < 4000.0) {
                config->sample_rate = default_pcm.sample_rate;
        }
        if (config->sample_rate > 48000.0) {
                config->sample_rate = 48000.0;
        }
        if (config->channels < 1) {
                config->channels = default_pcm.channels;
        }
        if (config->channels > 2) {
                config->channels = default_pcm.channels;
        }
        /* secret format of format: upper nybble = signed, unsigned, float */
        /* lower nybble = bytes per sample */
        if ((config->format != 0x11) && (config->format != 0x2) &&
                (config->format != 0x24) && (config->format != 0x4)) {
                config->format = default_pcm.format;
        }
        if (config->buf_header < 0) {
                config->buf_header = 0;
        }

        /* figure out buffer size that's a power of two and within size limits */
        if (!config->play_buf_size) {
                /* default is 256 samples for a comfy 6 ms latency */
                s = 256*config->channels*(config->format&0xf);
        }       /* minimum is 32 samples for a more extreme 0.75ms latency */
        else for (s = 32*config->channels*(config->format&0xf); s < MIN_MEMORY_SIZE/2; s = (s<<1)) {
                if (s >= config->play_buf_size) {
                        break;
                }
        }
        config->play_buf_size = s;
        if (!config->rec_buf_size) {
                s = 256*config->channels*(config->format&0xf);
        }
        else for (s = 32*config->channels*(config->format&0xf); s < MIN_MEMORY_SIZE/2; s = (s<<1)) {
                if (s >= config->rec_buf_size) {
                        break;
                }
        }
        config->rec_buf_size = s;

        /* calculate m, n and r (and asr) */

        if (!force && abs(config->sample_rate - port->config.sample_rate) < config->sample_rate/250) {
                n = -1;
        }
        else if (config->sample_rate == 48000.0) {
                asr = 7;
        }
        else if (config->sample_rate == 32000.0) {
                asr = 6;
        }
        else if (config->sample_rate == 16000.0) {
                asr = 5;
        }
        else if (config->sample_rate == 8000.0) {
                asr = 4;
        }
        else if (config->sample_rate == 44100.0) {
                asr = 3;
        }
        else if (config->sample_rate == 22050.0) {
                asr = 2;
        }
        else if (config->sample_rate == 11025.0) {
                asr = 1;
        }
        else {
                float freq;
                float delta = 1000000.0;
                int sr = -1;
                int sn = -1;
                int sm = -1;
                float diff;

                for (r=0; r<8; r++) {
                        if ((1<<r)*config->sample_rate*512 < MIN_FREQ) {
                                continue;
                        }
                        break;
                }
                if (r == 8) {
                        OLDAPI(("cmedia_pci: r value is 8!\n"));
                        r = 7;
                }
                n = 0;
                do {
                        n++;
                        m = config->sample_rate*512/1000*(n+2)*(1<<r)/(F_REF/1000)-2;
                        if (m < 1) {
                                continue;
                        }
                        if (m > 255) {
                                ddprintf(("cmedia_pci: m > 255; outahere\n"));
                                break;
                        }
                        freq = (m+2)*(F_REF/1000)/(512*(n+2)*(1<<r)/1000);
                        diff = freq-config->sample_rate;
                        if (diff < 0) {
                                diff = -diff;
                        }
                        if (diff < delta) {
                                sr = r;
                                sn = n;
                                sm = m;
                        }
                } while (n < 31);
                r = sr;
                n = sn;
                m = sm;
                ddprintf(("cmedia_pci: m = %d   r = %d   n = %d\n", m, r, n));
        }

        /* configure device */

        if (!force) {
                stop_dma(port);
                /* should mute PCM out, too */
        }
        if (asr > -1 || n > -1) { /* new sampling rate */
                if (asr > -1) {
                        port->config.sample_rate = config->sample_rate;
                        set_direct(port->card, 0x05, (asr<<5)|(asr<<2), 0xfc);
                }
                else {
                        port->config.sample_rate = ((float)m+2.0)*(F_REF/1000.0)/
                                (0.512*(n+2.0)*(1<<r));
                        config->sample_rate = port->config.sample_rate;
#if 1
                        /* not exact the frequency supported */
#else
                        set_indirect(port->card, 0x24, m, 0xff);
                        set_indirect(port->card, 0x25, (r<<5)|n, 0xff);
                        set_indirect(port->card, 0x22, 0x00, 0xff);
#endif
                }
        }
        if (force || config->channels != port->config.channels ||
                config->format != port->config.format) {
                uchar val = 0;
                if (config->channels == 2) {
                        val |= 0x01;    /* stereo */
                }
                if (config->format != 0x11) {
                        val |= 0x02;    /* 16 bits */
                }
                set_direct(port->card, 0x08, (val<<2)|val, 0x0f); /* MCE -- may take time to take effect */
                port->config.channels = config->channels;
                port->config.format = config->format;
        }
        if (force || config->big_endian != port->config.big_endian) {
                port->config.big_endian = config->big_endian;
        }
        if (force || config->buf_header != port->config.buf_header) {
                port->config.buf_header = config->buf_header;
        }
        if (force || config->play_buf_size != port->config.play_buf_size*2) {
                port->config.play_buf_size = config->play_buf_size*2;   /* because we break it in two */
        }
        if (force || config->rec_buf_size != port->config.rec_buf_size*2) {
                port->config.rec_buf_size = config->rec_buf_size*2;     /* because we break it in two */
        }

/* here is where we should care about record and playback buffer sizes */

        ddprintf(("cmedia_pci: play %04lx rec %04lx\n", port->config.play_buf_size/2,
                port->config.rec_buf_size/2));

        port->wr_1 = port->card->low_mem;
        port->wr_2 = port->wr_1+port->config.play_buf_size/2;
        port->wr_size = port->config.play_buf_size/2;

        port->rd_1 = port->card->low_mem+port->config.play_buf_size;
        port->rd_2 = port->rd_1+port->config.rec_buf_size/2;
        port->rd_size = port->config.rec_buf_size/2;

        if (!force) {
                /* should un-mute PCM out, if we muted it */
                start_dma(port);
        }
        return err;
}


static status_t
pcm_open(
        const char * name,
        uint32 flags,
        void ** cookie)
{
        int ix;
        pcm_dev * port = NULL;
        char name_buf[256];
        int32 prev_mode;

        ddprintf(("cmedia_pci: pcm_open()\n"));

        *cookie = NULL;
        for (ix=0; ix<num_cards; ix++) {
                if (!strcmp(name, cards[ix].pcm.name)) {
                        goto gotit;
                }
        }
        for (ix=0; ix<num_cards; ix++) {
                if (!strcmp(name, cards[ix].pcm.oldname)) {
                        goto gotit;
                }
        }
        ddprintf(("cmedia_pci: %s not found\n", name));
        return ENODEV;

gotit:
        *cookie = port = &cards[ix].pcm;

        acquire_sem(port->init_sem);

        prev_mode = port->open_mode;
        if ((flags & 3) == O_RDONLY) {
                atomic_or(&port->open_mode, kRecord);
        }
        else if ((flags & 3) == O_WRONLY) {
                atomic_or(&port->open_mode, kPlayback);
        }
        else {
                atomic_or(&port->open_mode, kPlayback|kRecord);
        }

        if (atomic_add(&port->open_count, 1) == 0) {

                /* initialize device first time */

                port->card = &cards[ix];
                port->config = default_pcm;
                port->config.play_buf_size *= 2;
                port->config.rec_buf_size *= 2;

                /* playback */
                B_INITIALIZE_SPINLOCK(&port->wr_lock);
                port->dma_a = cards[ix].dma_base;
                port->wr_1 = cards[ix].low_mem;
                port->wr_2 = cards[ix].low_mem+port->config.play_buf_size/2;
                port->wr_size = port->config.play_buf_size/2;
                port->write_waiting = 0;
                sprintf(name_buf, "WS:%s", port->name);
                name_buf[B_OS_NAME_LENGTH-1] = 0;
                port->write_sem = create_sem(0, name_buf);
                if (port->write_sem < B_OK) {
                        port->open_count = 0;
                        return port->write_sem;
                }
                set_sem_owner(port->write_sem, B_SYSTEM_TEAM);
                name_buf[0] = 'W'; name_buf[1] = 'E';
                port->wr_entry = create_sem(1, name_buf);
                if (port->wr_entry < B_OK) {
                        delete_sem(port->write_sem);
                        port->open_count = 0;
                        return port->wr_entry;
                }
                set_sem_owner(port->wr_entry, B_SYSTEM_TEAM);
                name_buf[1] = 'T';
                port->wr_time_wait = 0;
                port->wr_time_sem = create_sem(0, name_buf);
                if (port->wr_time_sem < B_OK) {
                        delete_sem(port->write_sem);
                        delete_sem(port->wr_entry);
                        port->open_count = 0;
                        return port->wr_time_sem;
                }
                set_sem_owner(port->wr_time_sem, B_SYSTEM_TEAM);

                /* recording */

                B_INITIALIZE_SPINLOCK(&port->rd_lock);
                port->dma_c = cards[ix].dma_base+0x08;
                port->rd_1 = cards[ix].low_mem+port->config.play_buf_size;
                port->rd_2 = cards[ix].low_mem+port->config.play_buf_size+port->config.rec_buf_size/2;
                port->rd_size = port->config.rec_buf_size/2;
                port->read_waiting = 0;
                name_buf[0] = 'R'; name_buf[1] = 'S';
                port->read_sem = create_sem(0, name_buf);
                if (port->read_sem < B_OK) {
                        delete_sem(port->write_sem);
                        delete_sem(port->wr_entry);
                        delete_sem(port->wr_time_sem);
                        port->open_count = 0;
                        return port->read_sem;
                }
                set_sem_owner(port->read_sem, B_SYSTEM_TEAM);
                name_buf[0] = 'R'; name_buf[1] = 'E';
                port->rd_entry = create_sem(1, name_buf);
                if (port->rd_entry < B_OK) {
                        delete_sem(port->write_sem);
                        delete_sem(port->wr_entry);
                        delete_sem(port->read_sem);
                        delete_sem(port->wr_time_sem);
                        port->open_count = 0;
                        return port->rd_entry;
                }
                set_sem_owner(port->rd_entry, B_SYSTEM_TEAM);
                name_buf[1] = 'T';
                port->rd_time_wait = 0;
                port->rd_time_sem = create_sem(0, name_buf);
                if (port->rd_time_sem < B_OK) {
                        delete_sem(port->write_sem);
                        delete_sem(port->wr_entry);
                        delete_sem(port->read_sem);
                        delete_sem(port->wr_time_sem);
                        delete_sem(port->rd_entry);
                        port->open_count = 0;
                        return port->rd_time_sem;
                }
                set_sem_owner(port->rd_time_sem, B_SYSTEM_TEAM);

                port->rd_time = 0;
                port->next_rd_time = 0;
                port->wr_time = 0;

                /* old API */

                port->old_cap_sem = -1;
                port->old_play_sem = -1;

                /* configuration */

                configure_pcm(port, &default_pcm, true);

                /* interrupts */
                KTRACE();
                increment_interrupt_handler(port->card);

                set_direct(port->card, 0x0e, 0x03, 0x03);       /* */
                start_dma(port);

                /* initialization is done, let other clients of the driver go */
        } else {
                if (prev_mode != port->open_mode) {
                        pcm_cfg temp = port->config;
                        temp.play_buf_size /= 2;
                        temp.rec_buf_size /= 2;
                        configure_pcm(port, &temp, false);      /* change rec/play if needed */
                }
        }
        release_sem(port->init_sem);

#if DEBUG
        dump_card(&cards[ix]);
#endif

        return B_OK;
}


static status_t
pcm_close(
        void * cookie)
{
        pcm_dev * port = (pcm_dev *)cookie;
        cpu_status cp;
        int spin = 0;

        ddprintf(("cmedia_pci: pcm_close()\n"));

        acquire_sem(port->init_sem);

        if (atomic_add(&port->open_count, -1) == 1) {

                KTRACE();
                cp = disable_interrupts();
                acquire_spinlock(&port->card->hardware);

                /* turn off interrupts */
                stop_dma(port);
                set_direct(port->card, 0x0e, 0x00, 0x03);       /* */

                if (port->config.format == 0x11) {
                        memset((void *)port->wr_1, 0x80, port->config.play_buf_size);   /* play silence */
                }
                else {
                        memset((void *)port->wr_1, 0, port->config.play_buf_size);      /* play silence */
                }
                spin = 1;

                release_spinlock(&port->card->hardware);
                restore_interrupts(cp);

                delete_sem(port->write_sem);
                delete_sem(port->read_sem);
                delete_sem(port->wr_entry);
                delete_sem(port->rd_entry);
                delete_sem(port->rd_time_sem);
                delete_sem(port->wr_time_sem);
                port->write_sem = -1;
                port->read_sem = -1;
                port->wr_entry = -1;
                port->rd_entry = -1;
                port->rd_time_sem = -1;
                port->wr_time_sem = -1;
        }
        release_sem(port->init_sem);

        if (spin) {
                /* wait so we know FIFO gets filled with silence */
                snooze(port->config.play_buf_size*1000/(port->config.sample_rate*
                        (port->config.format&0xf)*port->config.channels/1000));
        }
        return B_OK;
}


static status_t
pcm_free(
        void * cookie)
{
        cpu_status cp;
        pcm_dev * port = (pcm_dev *)cookie;

        ddprintf(("cmedia_pci: pcm_free()\n"));

        acquire_sem(port->init_sem);

        if (((pcm_dev *)cookie)->open_count == 0) {

                /* the last free will actually stop everything  */

                KTRACE();
                cp = disable_interrupts();
                acquire_spinlock(&port->card->hardware);

                decrement_interrupt_handler(port->card);

                release_spinlock(&port->card->hardware);
                restore_interrupts(cp);
        }
        release_sem(port->init_sem);

        return B_OK;
}


static status_t
pcm_control(
        void * cookie,
        uint32 iop,
        void * data,
        size_t len)
{
        // declarations for SPDIF settings I/O
        uchar reg_value;
        char DriverVersion[] = "1.3.2 (Jul 17, 2001)";

        pcm_dev * port = (pcm_dev *)cookie;
        status_t err = B_BAD_VALUE;
        pcm_cfg config = port->config;
        static float rates[7] = { 48000.0, 44100.0, 32000.0, 22050.0, 16000.0, 11025.0, 8000.0 };
        bool configure = false;
        config.play_buf_size /= 2;
        config.rec_buf_size /= 2;

        ddprintf(("cmedia_pci: pcm_control()\n"));

        switch (iop) {
        case B_AUDIO_GET_AUDIO_FORMAT:
                memcpy(data, &config, sizeof(port->config));
                err = B_OK;
                break;
        case B_AUDIO_GET_PREFERRED_SAMPLE_RATES:
                memcpy(data, rates, sizeof(rates));
                err = B_OK;
                break;
        case B_AUDIO_SET_AUDIO_FORMAT:
                memcpy(&config, data, sizeof(config));
                configure = true;
                err = B_OK;
                break;
        case SV_RD_TIME_WAIT:
                atomic_add(&port->rd_time_wait, 1);
                err = acquire_sem(port->rd_time_sem);
                if (err >= B_OK) {
                        cpu_status cp;
                        KTRACE();
                        cp = disable_interrupts();
                        acquire_spinlock(&port->rd_lock);
                        ((sv_timing *)data)->time = port->rd_time;
                        ((sv_timing *)data)->bytes = port->rd_total;
                        ((sv_timing *)data)->skipped = port->rd_skipped;
                        ((sv_timing *)data)->_reserved_[0] = 0xffffffffUL;
                        release_spinlock(&port->rd_lock);
                        restore_interrupts(cp);
                }
                break;
        case SV_WR_TIME_WAIT:
                atomic_add(&port->wr_time_wait, 1);
                err = acquire_sem(port->wr_time_sem);
                if (err >= B_OK) {
                        cpu_status cp;
                        KTRACE();
                        cp = disable_interrupts();
                        acquire_spinlock(&port->wr_lock);
                        ((sv_timing *)data)->time = port->wr_time;
                        ((sv_timing *)data)->bytes = port->wr_total;
                        ((sv_timing *)data)->skipped = port->wr_skipped;
                        ((sv_timing *)data)->_reserved_[0] = 0xffffffffUL;
                        release_spinlock(&port->wr_lock);
                        restore_interrupts(cp);
                }
                break;
        case SV_SECRET_HANDSHAKE: {
                cpu_status cp;
                KTRACE();
                cp = disable_interrupts();
                acquire_spinlock(&port->wr_lock);
                acquire_spinlock(&port->rd_lock);
                ((sv_handshake *)data)->wr_time = port->wr_time;
                ((sv_handshake *)data)->wr_skipped = port->wr_skipped;
                ((sv_handshake *)data)->rd_time = port->rd_time;
                ((sv_handshake *)data)->rd_skipped = port->rd_skipped;
                ((sv_handshake *)data)->wr_total = port->wr_total;
                ((sv_handshake *)data)->rd_total = port->rd_total;
                ((sv_handshake *)data)->_reserved_[0] = 0xffffffffUL;
                err = B_OK;
                release_spinlock(&port->rd_lock);
                release_spinlock(&port->wr_lock);
                restore_interrupts(cp);
                } break;
        case SOUND_GET_PARAMS: {
                cpu_status cp;
                uchar u;
                sound_setup * sound = (sound_setup *)data;
                err = B_OK;
                cp = disable_interrupts();
                acquire_spinlock(&port->card->hardware);
                /* Here we get to hard-code the mix/mux values. */
                /* Huh-huh; he said "hard-code"! */
                sound->sample_rate = kHz_44_1;
                if (!port->config.big_endian == !B_HOST_IS_BENDIAN) {
                        sound->playback_format = linear_16bit_big_endian_stereo;
                        sound->capture_format = linear_16bit_big_endian_stereo;
                }
                else {
                        sound->playback_format = linear_16bit_little_endian_stereo;
                        sound->capture_format = linear_16bit_little_endian_stereo;
                }
                sound->dither_enable = false;
                sound->loop_attn = 0;
                sound->loop_enable = 0;
                sound->output_boost = 0;
                sound->highpass_enable = 0;
                /* this is a master control on C-Media... */
                u = get_indirect(port->card, 0x30)>>2;
                sound->mono_gain = u&63;
                sound->mono_mute = 0;

                /* left channel */
                u = get_indirect(port->card, 0x3d); // Legacy SB compatible Mixer
                switch (u)
                {
                case 0x10:
                        sound->left.adc_source = line;          //      record line left
                        break;

                case 4:
                        sound->left.adc_source = aux1;          // record CD left ??
                        break;

                case 1:
                        sound->left.adc_source = mic;           // record mic left
                        break;

                default:
                        sound->left.adc_source = loopback;
                        break;
                }
                u = get_indirect(port->card, 0x3f)>>4;
                sound->left.adc_gain = u&15;

                u = get_direct(port->card, 0x25)<<4;
                sound->left.mic_gain_enable = u&16;

                u = get_indirect(port->card, 0x36)>>3;
                sound->left.aux1_mix_gain = 31-(u&31);

                u = get_indirect(port->card, 0x3c)<<5;
                sound->left.aux1_mix_mute = ~u&128;

                u = get_indirect(port->card, 0x34)>>3;
                sound->left.aux2_mix_gain = 31-(u&31);

                u = get_direct(port->card, 0x24);
                sound->left.aux2_mix_mute = u&128;

                u = get_indirect(port->card, 0x38)>>3;
                sound->left.line_mix_gain = 31-(u&31);

                u = get_indirect(port->card, 0x3c)<<3;
                sound->left.line_mix_mute = ~u&128;

                u = get_indirect(port->card, 0x32)>>2;
                sound->left.dac_attn = 63-(u&63);

                u = get_direct(port->card, 0x24)<<1;
                sound->left.dac_mute = u&128;

                /* right channel */
                u = get_indirect(port->card, 0x3e);
                switch (u)
                {
                case 8:
                        sound->right.adc_source = line;         //record line right
                        break;

                case 2:
                        sound->right.adc_source = aux1;         // record CD right?
                        break;

                case 1:
                        sound->right.adc_source = mic;          // record mic right
                        break;

                default:
                        sound->right.adc_source = loopback;
                        break;
                }
                u = get_indirect(port->card, 0x40)>>4;
                sound->right.adc_gain = u&15;
                sound->right.mic_gain_enable = sound->left.mic_gain_enable;
                u = get_indirect(port->card, 0x37)>>3;
                sound->right.aux1_mix_gain = 31-(u&31);
                u = get_indirect(port->card, 0x3c)<<6;
                sound->right.aux1_mix_mute = ~u&128;
                u = get_indirect(port->card, 0x35)>>3;
                sound->right.aux2_mix_gain = 31-(u&31);
                u = get_direct(port->card, 0x24);
                sound->right.aux2_mix_mute = u&128;
                u = get_indirect(port->card, 0x39)>>3;
                sound->right.line_mix_gain = 31-(u&31);
                u = get_indirect(port->card, 0x3c)<<4;
                sound->right.line_mix_mute = ~u&128;
                u = get_indirect(port->card, 0x33)>>2;
                sound->right.dac_attn = 63-(u&63);
                u = get_direct(port->card, 0x24)<<1;
                sound->right.dac_mute = u&128;
                /* done */
                release_spinlock(&port->card->hardware);
                restore_interrupts(cp);
                } break;
        case SOUND_SET_PARAMS: {
                cpu_status cp;
                uchar u;
                sound_setup * sound = (sound_setup *)data;
                err = B_OK;
                cp = disable_interrupts();
                acquire_spinlock(&port->card->hardware);
                /* Here we get to hard-code the mix/mux values. */
                /* Huh-huh; he said "hard-code"! */

                /* ignore sample rate */
                sound->sample_rate = kHz_44_1;
                if (config.sample_rate < 43999 || config.sample_rate > 44201) {
                        config.sample_rate = 44100.0;
                        configure = true;
                }
                /* we only support 16-bit formats */
                if (sound->playback_format == linear_16bit_big_endian_stereo &&
                        sound->capture_format == linear_16bit_big_endian_stereo) {
                        if (!config.big_endian != !B_HOST_IS_BENDIAN || config.format != 0x2) {
                                config.big_endian = B_HOST_IS_BENDIAN;
                                config.format = 0x2;
                                configure = true;
                        }
                        OLDAPI(("same_endian\n"));
                }
                else if (sound->playback_format == linear_16bit_little_endian_stereo &&
                        sound->capture_format == linear_16bit_little_endian_stereo) {
                        if (!config.big_endian != !!B_HOST_IS_BENDIAN || config.format != 0x2) {
                                config.big_endian = !B_HOST_IS_BENDIAN;
                                config.format = 0x2;
                                configure = true;
                        }
                        OLDAPI(("other_endian\n"));
                }
                else {
                        config.big_endian = !!B_HOST_IS_BENDIAN;
                        configure = true;
                        OLDAPI(("other format!!!\n"));
                }
                /* ignore these values */
                sound->dither_enable = false;
                sound->loop_attn = 0;
                sound->loop_enable = 0;
                sound->output_boost = 0;
                sound->highpass_enable = 0;
                /* this is a stereo control on C-Media... */
                u = (sound->mono_gain>>1)&0x1f;
                OLDAPI(("output: %x\n", u));
                set_indirect(port->card, 0x30, u<<3, 0xff);
                set_indirect(port->card, 0x31, u<<3, 0xff);
                /* left channel */
                switch (sound->left.adc_source)
                {
                case line:
                        u = 1<<4;
                        break;
                case aux1:
                        u = 1<<2;
                        break;
                case mic:
                        u = 1<<0;
                        break;
                default:
                        u = 0x15;
                        break;
                }
                OLDAPI(("input: %x\n", u));
                set_indirect(port->card, 0x3d, u, 0xff);
                u = (sound->left.adc_gain&15);
                set_indirect(port->card, 0x3f, u<<4, 0xff);
                u = sound->left.mic_gain_enable ? 0 : 0x01;
                set_direct(port->card, 0x25, u, 0x01);
                u = 31-(sound->left.aux1_mix_gain&31);
                OLDAPI(("cd: %x\n", u));
                set_indirect(port->card, 0x36, u<<3, 0xff);
                u = sound->left.aux1_mix_mute ? 0 : 0x04;
                set_indirect(port->card, 0x3c, u, 0x04);
                u = 31-(sound->left.aux2_mix_gain&31);
                OLDAPI(("aux2: %x\n", u));
                set_indirect(port->card, 0x34, u<<3, 0xff);
                u = sound->left.aux2_mix_mute ? 0x80 : 0;
                set_direct(port->card, 0x24, u, 0x80);
                u = 31-(sound->left.line_mix_gain&31);
                OLDAPI(("line: %x\n", u));
                set_indirect(port->card, 0x38, u<<3, 0xff);
                u = sound->left.line_mix_mute ? 0 : 0x10;
                set_indirect(port->card, 0x3c, u, 0x10);
                u = 63-(sound->left.dac_attn & 63);
                OLDAPI(("PCM: %x\n", u));
                set_indirect(port->card, 0x32, u<<2, 0xff);
                u = sound->left.dac_mute ? 0x40 : 0;
                set_direct(port->card, 0x24, u, 0x40);
                /* right channel */
                switch (sound->right.adc_source) {
                case line:
                        u = 1<<3;
                        break;
                case aux1:
                        u = 1<<1;
                        break;
                case mic:
                        u = 1<<0;
                        break;
                default:
                        u = 0x0a;
                        break;
                }
                sound->right.mic_gain_enable = sound->left.mic_gain_enable;
                set_indirect(port->card, 0x3e, u, 0xff);
                u = (sound->right.adc_gain&15);
                set_indirect(port->card, 0x40, u<<4, 0xff);
                u = sound->right.mic_gain_enable ? 0 : 0x01;
                set_direct(port->card, 0x25, u, 0x01);
                u = 31-(sound->right.aux1_mix_gain&31);
                set_indirect(port->card, 0x37, u<<3, 0xff);
                u = sound->right.aux1_mix_mute ? 0 : 0x02;
                set_indirect(port->card, 0x3c, u, 0x02);
                u = 31-(sound->right.aux2_mix_gain&31);
                set_indirect(port->card, 0x35, u<<3, 0xff);
                u = sound->right.aux2_mix_mute ? 0x80 : 0;
                set_direct(port->card, 0x24, u, 0x80);
                u = 31-(sound->right.line_mix_gain&31);
                set_indirect(port->card, 0x39, u<<3, 0xff);
                u = sound->right.line_mix_mute ? 0 : 0x08;
                set_indirect(port->card, 0x3c, u, 0x08);
                u = 63-(sound->right.dac_attn & 63);
                set_indirect(port->card, 0x33, u<<2, 0xff);
                u = sound->right.dac_mute ? 0x40 : 0;
                set_direct(port->card, 0x24, u, 0x40);
                /* done */
                release_spinlock(&port->card->hardware);
                restore_interrupts(cp);
                } break;
        case SOUND_SET_PLAYBACK_COMPLETION_SEM:
                port->old_play_sem = *(sem_id *)data;
                err = B_OK;
                break;
        case SOUND_SET_CAPTURE_COMPLETION_SEM:
                port->old_cap_sem = *(sem_id *)data;
                err = B_OK;
                break;
//      case SOUND_GET_PLAYBACK_TIMESTAMP:
//              break;
//      case SOUND_GET_CAPTURE_TIMESTAMP:
//              break;
//      case SOUND_DEBUG_ON:
//              break;
//      case SOUND_DEBUG_OFF:
//              break;
        case SOUND_UNSAFE_WRITE: {
                audio_buffer_header * buf = (audio_buffer_header *)data;
                size_t n = buf->reserved_1-sizeof(*buf);
                pcm_write(cookie, 0, buf+1, &n);
                buf->time = port->wr_time;
                buf->sample_clock = port->wr_total/4 * 10000 / 441;
                err = release_sem(port->old_play_sem);
                } break;
        case SOUND_UNSAFE_READ: {
                audio_buffer_header * buf = (audio_buffer_header *)data;
                size_t n = buf->reserved_1-sizeof(*buf);
                pcm_read(cookie, 0, buf+1, &n);
                buf->time = port->rd_time;
                buf->sample_clock = port->rd_total/4 * 10000 / 441;
                err = release_sem(port->old_cap_sem);
                } break;
        case SOUND_LOCK_FOR_DMA:
                err = B_OK;
                break;
        case SOUND_SET_PLAYBACK_PREFERRED_BUF_SIZE:
                config.play_buf_size = (intptr_t)data;
                configure = true;
                err = B_OK;
                break;
        case SOUND_SET_CAPTURE_PREFERRED_BUF_SIZE:
                config.rec_buf_size = (intptr_t)data;
                configure = true;
                err = B_OK;
                break;
        case SOUND_GET_PLAYBACK_PREFERRED_BUF_SIZE:
                *(int32*)data = config.play_buf_size;
                err = B_OK;
                break;
        case SOUND_GET_CAPTURE_PREFERRED_BUF_SIZE:
                *(int32*)data = config.rec_buf_size;
                err = B_OK;
                break;


// control ports for SPDIF settings
        case SOUND_GET_SPDIF_IN_OUT_LOOPBACK:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x04 );
                if( reg_value && 0x80 ) *(int8 *)data = 1;
                err = B_OK;
                break;

        case SOUND_SET_SPDIF_IN_OUT_LOOPBACK:
                if( *(int8 *)data == 0 ) // disable SPDIF-IN loopback to SPDIF (bypass)
                        set_direct( port->card, 0x04, 0x00, 0x80 );
                else // enable SPDIF-IN loopback to SPDIF (bypass)
                        set_direct( port->card, 0x04, 0x80, 0x80 );
                err = B_OK;
                break;




        case SOUND_GET_SPDIF_OUT:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x16 );                     // Adresse 0x16
                if( reg_value && 0x80 ) *(int8 *)data = 1;
                err = B_OK;
                break;

        case SOUND_SET_SPDIF_OUT:
                if( *(int8 *)data == 0 ) // disable SPDIF-OUT
                        set_direct( port->card, 0x16, 0x00, 0x80);
                else // enable SPDIF-OUT
                        set_direct( port->card, 0x16, 0x80, 0x80 );
                err = B_OK;
                break;



        case SOUND_GET_SPDIF_MONITOR:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x24 );
                if( reg_value && 0x01 ) *(int8 *)data = 1;
                err = B_OK;
                break;


        case SOUND_SET_SPDIF_MONITOR:
                if( *(int8 *)data == 0 ) // disable SPDIF_IN PCM to DAC (CDPlay)
                        set_direct( port->card, 0x24, 0x00, 0x01 );
                else // enable SPDIF_IN PCM to DAC (CDPlay)
                        set_direct( port->card, 0x24, 0x01, 0x01 );
                err = B_OK;
                break;

        case SOUND_GET_SPDIF_OUT_LEVEL:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x1b );
                if( reg_value && 0x02 ) *(int8 *)data = 1;
                err = B_OK;
                break;

        case SOUND_SET_SPDIF_OUT_LEVEL:
                if( *(int8 *)data == 0 ) // enable SPDIF-OUT optical
                        set_direct( port->card, 0x1b, 0x00, 0x02 );
                else // enable SPDIF-OUT coaxial
                        set_direct( port->card, 0x1b, 0x02, 0x02 );
                break;

        case SOUND_GET_SPDIF_IN_FORMAT:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x08 );             // Adresse 0x08
                if( reg_value && 0x80 ) *(int8 *)data = 1;
                err = B_OK;
                break;


        case SOUND_SET_SPDIF_IN_FORMAT:
                if( *(int8 *)data == 0 ) // disable SPDIF inverse (SPDIF normal)
                        set_direct( port->card, 0x08, 0x00, 0x80 );
                else // enable SPDIF inverse
                        set_direct( port->card, 0x08, 0x80, 0x80 );     // Adresse 0x08, Daten 0x80
                err = B_OK;
                break;


        case SOUND_GET_SPDIF_IN_OUT_COPYRIGHT:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x16 );
                if( reg_value && 0x40 ) *(int8 *)data = 1;
                err = B_OK;
                break;

        case SOUND_SET_SPDIF_IN_OUT_COPYRIGHT:
                if( *(int8 *)data == 0 ) // disable SPDIF-IN/OUT copyright protection
                        set_direct( port->card, 0x16, 0x00, 0x40 );
                else // enable SPDIF-IN/OUT copyright protection
                        set_direct( port->card, 0x16, 0x40, 0x40 );
                err = B_OK;
                break;

        case SOUND_GET_SPDIF_IN_VALIDITY:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x27 );
                if( reg_value && 0x02 ) *(int8 *)data = 1;
                err = B_OK;
                break;

        case SOUND_SET_SPDIF_IN_VALIDITY:
                if( *(int8 *)data == 0 ) // disable SPDIF-IN validity detection
                        set_direct( port->card, 0x27, 0x00, 0x02 );
                else // enable SPDIF-IN validity detection
                        set_direct( port->card, 0x27, 0x02, 0x02 );
                err = B_OK;
                break;
// control ports for analog settings

        case SOUND_GET_4_CHANNEL_DUPLICATE:
                *(int8 *)data = 0;
                reg_value = get_direct( port->card, 0x1b );
                if( reg_value && 0x04 ) *(int8 *)data = 1;

//              0x1b, 0x04, 0x04,       /* dual channel mode enable */
//              0x1a, 0x00, 0x80,       /* Double DAC structure disable */

                err = B_OK;
                break;

        case SOUND_SET_4_CHANNEL_DUPLICATE:
                if( *(int8 *)data == 0 ) // disable 4 channel analog duplicate mode
                        set_direct( port->card, 0x1b, 0x00, 0x04 );
                else // enable 4 channel analog duplicate mode
                        set_direct( port->card, 0x1b, 0x04, 0x04 );
                err = B_OK;
                break;
// control ports for additional info

        case SOUND_GET_DEVICE_ID:
//              *(int32*)data.vendor_id = cards[0].info.vendor_id;
//              *(int32*)data.device_id = cards[0].info.device_id;

//              static int32 chipinfo[] = { 0,0 };
//              chipinfo[0] = cards[0].info.vendor_id;
                *(int32*)data = cards[0].info.device_id;

//              memcpy(data, &chipinfo, sizeof(chipinfo));
                err = B_OK;
                break;

        case SOUND_GET_INTERNAL_CHIP_ID:
                // XXX
                break;

        case SOUND_GET_DRIVER_VERSION:
                memcpy(data, &DriverVersion, sizeof(DriverVersion));
                break;

        default:
                OLDAPI(("cmedia_pci: unknown code %ld\n", iop));
                err = B_BAD_VALUE;
                break;
        }
        if ((err == B_OK) && configure) {
                cpu_status cp;
                KTRACE();
                cp = disable_interrupts();
                acquire_spinlock(&port->card->hardware);
                err = configure_pcm(port, &config, false);
                release_spinlock(&port->card->hardware);
                restore_interrupts(cp);
        }
        return err;
}


static void
copy_short_to_float(
        float * f,
        const short * s,
        int c,
        int endian)     /*      endian means float data in big-endian   */
{
        if (endian) {
                while (c > 1) {
                        short sh = B_LENDIAN_TO_HOST_FLOAT(*s);
                        *(f++) = B_HOST_TO_BENDIAN_FLOAT((float)B_LENDIAN_TO_HOST_INT16(sh));
                        s++;
                        c -= 2;
                }
        }
        else {
                while (c > 1) {
                        short sh = B_LENDIAN_TO_HOST_FLOAT(*s);
                        *(f++) = B_HOST_TO_LENDIAN_FLOAT((float)B_LENDIAN_TO_HOST_INT16(sh));
                        s++;
                        c -= 2;
                }
        }
}


static void
copy_float_to_short(
        short * s,
        const float * f,
        int c,
        int endian)     /*      endian means float data in big-endian   */
{
        if (endian) {
                while (c > 1) {
                        float fl = *(f++);
                        *(s++) = B_HOST_TO_LENDIAN_INT16((float)B_BENDIAN_TO_HOST_FLOAT(fl));
                        c -= 2;
                }
        }
        else {
                while (c > 1) {
                        float fl = *(f++);
                        *(s++) = B_HOST_TO_LENDIAN_INT16((float)B_LENDIAN_TO_HOST_FLOAT(fl));
                        c -= 2;
                }
        }
}


static void
swap_copy(
        short * dest,
        const short * src,
        int c)
{
        while (c > 1) {
                unsigned short sh = *(src++);
                *(dest++) = ((sh << 8) | (sh >> 8));
                c -= 2;
        }
}


static status_t
pcm_read(
        void * cookie,
        off_t pos,
        void * data,
        size_t * nread)
{
        pcm_dev * port = (pcm_dev *)cookie;
        size_t to_read = *nread;
        status_t err;
        size_t block;
        cpu_status cp;
        int bytes_xferred;
        void * hdrptr = data;
        int hdrsize = port->config.buf_header;
        cmedia_pci_audio_buf_header hdr;

//      ddprintf(("cmedia_pci: pcm_read()\n")); /* we're here */

        *nread = 0;
        data = ((char *)data)+hdrsize;
        to_read -= hdrsize;

        err = acquire_sem_etc(port->rd_entry, 1, B_CAN_INTERRUPT, 0);
        if (err < B_OK) {
                return err;
        }

        hdr.capture_time = port->rd_time;

        goto first_time;

        while (to_read > 0) {
                /* wait for more data */
                atomic_add(&port->read_waiting, 1);
                err = acquire_sem_etc(port->read_sem, 1, B_CAN_INTERRUPT, 0);
                if (err < B_OK) {
                        release_sem(port->rd_entry);
                        return err;
                }

first_time:     /* we need to check whether anything's available first */
                KTRACE();
                cp = disable_interrupts();
                acquire_spinlock(&port->rd_lock);

                block = port->rd_size-port->was_read;

                if (port->config.format == 0x24) {
                        if (block > (to_read>>1)) {     /*      floats expand by factor 2       */
                                block = to_read>>1;
                        }
                }
                else if (block > to_read) {
                        block = to_read;
                }
                switch (port->config.format) {
                case 0x24:      /*      floats  */
                        copy_short_to_float((float *)data, (const short *)(port->rd_cur+port->was_read),
                                block, !B_HOST_IS_LENDIAN == !port->config.big_endian);
                        bytes_xferred = block * 2;
                        break;
                case 0x02:      /*      shorts  */
                        if (!B_HOST_IS_LENDIAN == !port->config.big_endian) {
                                /*      we need to swap */
                                swap_copy((short *)data, (const short *)(port->rd_cur+port->was_read), block);
                                bytes_xferred = block;
                                break;
                        }
                        /*      else fall through to default case       */
                case 0x11:      /*      bytes   */
                default:
                        memcpy(data, (void *)(port->rd_cur+port->was_read), block);
                        bytes_xferred = block;
                        break;
                }
                port->was_read += block;

                release_spinlock(&port->rd_lock);
                restore_interrupts(cp);

                to_read -= bytes_xferred;
                data = ((char *)data)+bytes_xferred;
                *nread += bytes_xferred;
        }

        /*      provide header if requested     */
        if (hdrsize > 0) {
                ddprintf(("header %d\n", hdrsize));
                *nread += hdrsize;
                hdr.capture_size = *nread;
                hdr.sample_rate = port->config.sample_rate;
                if ((uint32)hdrsize > sizeof(hdr))
                        hdrsize = sizeof(hdr);

                memcpy(hdrptr, &hdr, hdrsize);
        }

        release_sem(port->rd_entry);

        return B_OK;
}


static status_t
pcm_write(
        void * cookie,
        off_t pos,
        const void * data,
        size_t * nwritten)
{
        pcm_dev * port = (pcm_dev *)cookie;
        status_t err;
        cpu_status cp;
        int written = 0;
        int to_write = *nwritten;       /*       in play bytes, not input bytes!        */
        int block;
        int bytes_xferred;

//      ddprintf(("cmedia_pci: pcm_write()\n")); /* we're here */

        *nwritten = 0;

        err = acquire_sem_etc(port->wr_entry, 1, B_CAN_INTERRUPT, 0);
        if (err < B_OK) {
                return err;
        }

        atomic_add(&port->write_waiting, 1);
        if (port->config.format == 0x24) {
                to_write >>= 1; /*      floats collapse by 2    */
        }
        while (to_write > 0) {

                /* wait to write */

                err = acquire_sem_etc(port->write_sem, 1, B_CAN_INTERRUPT, 0);
                if (err < B_OK) {
                        release_sem(port->wr_entry);
                        return err;
                }

#if DEBUG
                put_cnt++;
                {
                        bigtime_t delta = system_time() - the_time;
                        if (delta < 1) {
                                ddprintf(("cmedia_pci: delta %lld (low!) #%ld\n", delta, put_cnt));
                        }
                        else if (delta > 2000) {
                                ddprintf(("cmedia_pci: delta %lld (high!) #%ld\n", delta, put_cnt));
                        }
                }
                if (put_cnt != int_cnt) {
        static int last;
                        if (last != int_cnt-put_cnt)
                                OLDAPI(("cmedia_pci: %ld mismatch\n", int_cnt-put_cnt));
                        last = int_cnt-put_cnt;
                }
#endif /* DEBUG */

                KTRACE();
                cp = disable_interrupts();
                acquire_spinlock(&port->wr_lock);

                block = port->wr_size-port->was_written;
                if (block > to_write) {
                        /* must let next guy in */
                        if (atomic_add(&port->write_waiting, -1) > 0) {
                                release_sem_etc(port->write_sem, 1, B_DO_NOT_RESCHEDULE);
                        }
                        else {
                                atomic_add(&port->write_waiting, 1); /* undo damage */
                        }
                        block = to_write;
                }
                else if (block < to_write) {
                        atomic_add(&port->write_waiting, 1); /* we will loop back */
                }
                switch (port->config.format) {
                case 0x24:      /*      floats  */
                        copy_float_to_short((short *)(port->wr_cur+port->was_written), (const float *)data,
                                block, !B_HOST_IS_LENDIAN == !port->config.big_endian);
                        bytes_xferred = block * 2;
                        break;
                case 0x02:      /*      shorts  */
                        if (!B_HOST_IS_LENDIAN == !port->config.big_endian) {
                                /*      we need to swap */
                                swap_copy((short *)(port->wr_cur+port->was_written), (const short *)data, block);
                                bytes_xferred = block;
                                break;
                        }
                        /*      else fall through to default case       */
                case 0x11:      /*      bytes   */
                default:
                        memcpy((void *)(port->wr_cur+port->was_written), data, block);
                        bytes_xferred = block;
                        break;
                }
                port->was_written += block;
                port->wr_silence = 0;

                release_spinlock(&port->wr_lock);
                restore_interrupts(cp);

                data = ((char *)data)+bytes_xferred;
                written += bytes_xferred;
                to_write -= block;
        }

        *nwritten = written;
        release_sem(port->wr_entry);

        return B_OK;
}


bool
dma_a_interrupt(
        cmedia_pci_dev * dev)
{
        bool ret = false;
        pcm_dev * port = &dev->pcm;
        volatile uchar * ptr;
        uint32 addr;
        uint32 offs;
        bigtime_t st = system_time();
        int32 ww;

#if 0
ddprintf(("cmedia_pci: dma_a 0x%x+0x%x\n", PCI_IO_RD_32((int)port->dma_a), PCI_IO_RD_32((int)port->dma_a+4)));
#endif
//      KTRACE(); /* */
        acquire_spinlock(&port->wr_lock);

        if (port->write_sem < 0) {
                kprintf("cmedia_pci: spurious DMA A interrupt!\n");
                release_spinlock(&port->wr_lock);
                return false;
        }
        /* copy possible silence into playback buffer */

        if (port->was_written > 0 && port->was_written < port->wr_size) {
                if (port->config.format == 0x11) {
                        memset((void *)(port->wr_cur+port->was_written), 0x80, port->wr_size-port->was_written);
                }
                else {
                        memset((void *)(port->wr_cur+port->was_written), 0, port->wr_size-port->was_written);
                }
        }

        /* because the system may be lacking and not hand us the */
        /* interrupt in time, we check which half is currently being */
        /* played, and set the pointer to the other half */

        addr = PCI_IO_RD_32((uint32)port->dma_a);
        if ((offs = addr-(uint32)port->card->low_phys) < port->wr_size) {
                ptr = port->wr_2;
        }
        else {
                ptr = port->wr_1;
        }
        port->wr_total += port->config.play_buf_size/2;
        /* compensate for interrupt latency */
        /* assuming 4 byte frames */
        port->wr_time = st-(offs&(port->config.play_buf_size/2-1))*250000LL/(int64)port->config.sample_rate;
        if ((ww = atomic_add(&port->wr_time_wait, -1)) > 0) {
                release_sem_etc(port->wr_time_sem, 1, B_DO_NOT_RESCHEDULE);
                ret = true;
        }
        else {
                atomic_add(&port->wr_time_wait, 1); /* re-set to 0 */
        }

        if (port->wr_cur == ptr) {
                port->wr_skipped++;
                OLDAPI(("cmedia_pci: write skipped %ld\n", port->wr_skipped));
        }
        port->wr_cur = ptr;
        port->was_written = 0;

        /* check for client there to write into buffer */

        if (atomic_add(&port->write_waiting, -1) > 0) {
#if DEBUG
                int_cnt++;
                the_time = st;
#endif
                release_sem_etc(port->write_sem, 1, B_DO_NOT_RESCHEDULE);
                ret = true;
        }
        else {
                atomic_add(&port->write_waiting, 1);
                /* if none there, fill with silence */
                if (port->wr_silence < (int32)port->config.play_buf_size * 2) {
                        if (port->config.format == 0x11) {
                                memset((void *)ptr, 0x80, port->wr_size);
                        }
                        else {
                                memset((void *)ptr, 0, port->wr_size);
                        }
                        port->wr_silence += port->wr_size;
                }
        }
        /* copying will be done in user thread */

        release_spinlock(&port->wr_lock);
        return ret;
}


bool
dma_c_interrupt(
        cmedia_pci_dev * dev)
{
        bool ret = false;
        pcm_dev * port = &dev->pcm;
        volatile uchar * ptr;
        uint32 addr;
        uint32 offs;
        int32 rr;
        bigtime_t st = system_time();

        /* mark data as readable in record buffer */
#if 0
ddprintf(("cmedia_pci: dma_c 0x%x+0x%x\n", PCI_IO_RD_32((int)port->dma_c), PCI_IO_RD_32((int)port->dma_c+4)));
#endif
//      KTRACE(); /* */
        acquire_spinlock(&port->rd_lock);

        if (port->read_sem < 0) {
                kprintf("cmedia_pci: spurious DMA C interrupt!\n");
                release_spinlock(&port->rd_lock);
                return false;
        }
        /* if we lose an interrupt, we automatically avoid constant glitching by setting */
        /* the write pointer based on where the DMA counter is everytime */
        addr = PCI_IO_RD_32((uint32)port->dma_c);
        if ((offs = addr-port->config.play_buf_size-(uint32)port->card->low_phys) < port->rd_size) {
                ptr = port->rd_2;
        }
        else {
                ptr = port->rd_1;
        }
        if (port->rd_cur == ptr) {
                port->rd_skipped++;
                OLDAPI(("cmedia_pci: read skipped %ld\n", port->rd_skipped));
        }
        port->rd_total += port->rd_size;

        port->rd_cur = ptr;
        port->was_read = 0;
        port->rd_time = port->next_rd_time;
        /*      time stamp when this buffer became available -- compensate for interrupt latency        */
        port->next_rd_time = st-(offs&(port->config.rec_buf_size/2-1))*1000000LL/(int64)port->config.sample_rate;
        if ((rr = atomic_add(&port->rd_time_wait, -1)) > 0) {
                release_sem_etc(port->rd_time_sem, 1, B_DO_NOT_RESCHEDULE);
                ret = true;
        }
        else {
                atomic_add(&port->rd_time_wait, 1); /* re-set to 0 */
        }

        if (atomic_add(&port->read_waiting, -1) > 0) {
                release_sem_etc(port->read_sem, 1, B_DO_NOT_RESCHEDULE);
                ret = true;
        }
        else {
                atomic_add(&port->read_waiting, 1);
        }
        /* copying will be done in the user thread */
        release_spinlock(&port->rd_lock);
        return ret;
}