Archipelago » qemu

/*

 * TI OMAP processors emulation.

 *

 * Copyright (C) 2007-2008 Nokia Corporation

 * Written by Andrzej Zaborowski <andrew@openedhand.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 or

 * (at your option) version 3 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, see <http://www.gnu.org/licenses/>.

 */

#include "blockdev.h"

#include "hw.h"

#include "arm-misc.h"

#include "omap.h"

#include "sysemu.h"

#include "qemu-timer.h"

#include "qemu-char.h"

#include "flash.h"

#include "soc_dma.h"

#include "audio/audio.h"

/* Multichannel SPI */

struct omap_mcspi_s {

    qemu_irq irq;

    int chnum;

    uint32_t sysconfig;

    uint32_t systest;

    uint32_t irqst;

    uint32_t irqen;

    uint32_t wken;

    uint32_t control;

    struct omap_mcspi_ch_s {

        qemu_irq txdrq;

        qemu_irq rxdrq;

        uint32_t (*txrx)(void *opaque, uint32_t, int);

        void *opaque;

        uint32_t tx;

        uint32_t rx;

        uint32_t config;

        uint32_t status;

        uint32_t control;

    } ch[4];

};

static inline void omap_mcspi_interrupt_update(struct omap_mcspi_s *s)

{

    qemu_set_irq(s->irq, s->irqst & s->irqen);

}

static inline void omap_mcspi_dmarequest_update(struct omap_mcspi_ch_s *ch)

{

    qemu_set_irq(ch->txdrq,

                    (ch->control & 1) &&                /* EN */

                    (ch->config & (1 << 14)) &&                /* DMAW */

                    (ch->status & (1 << 1)) &&                /* TXS */

                    ((ch->config >> 12) & 3) != 1);        /* TRM */

    qemu_set_irq(ch->rxdrq,

                    (ch->control & 1) &&                /* EN */

                    (ch->config & (1 << 15)) &&                /* DMAW */

                    (ch->status & (1 << 0)) &&                /* RXS */

                    ((ch->config >> 12) & 3) != 2);        /* TRM */

}

static void omap_mcspi_transfer_run(struct omap_mcspi_s *s, int chnum)

{

    struct omap_mcspi_ch_s *ch = s->ch + chnum;

    if (!(ch->control & 1))                                /* EN */

        return;

    if ((ch->status & (1 << 0)) &&                        /* RXS */

                    ((ch->config >> 12) & 3) != 2 &&        /* TRM */

                    !(ch->config & (1 << 19)))                /* TURBO */

        goto intr_update;

    if ((ch->status & (1 << 1)) &&                        /* TXS */

                    ((ch->config >> 12) & 3) != 1)        /* TRM */

        goto intr_update;

    if (!(s->control & 1) ||                                /* SINGLE */

                    (ch->config & (1 << 20))) {                /* FORCE */

        if (ch->txrx)

            ch->rx = ch->txrx(ch->opaque, ch->tx,        /* WL */

                            1 + (0x1f & (ch->config >> 7)));

    }

    ch->tx = 0;

    ch->status |= 1 << 2;                                /* EOT */

    ch->status |= 1 << 1;                                /* TXS */

    if (((ch->config >> 12) & 3) != 2)                        /* TRM */

        ch->status |= 1 << 0;                                /* RXS */

intr_update:

    if ((ch->status & (1 << 0)) &&                        /* RXS */

                    ((ch->config >> 12) & 3) != 2 &&        /* TRM */

                    !(ch->config & (1 << 19)))                /* TURBO */

        s->irqst |= 1 << (2 + 4 * chnum);                /* RX_FULL */

    if ((ch->status & (1 << 1)) &&                        /* TXS */

                    ((ch->config >> 12) & 3) != 1)        /* TRM */

        s->irqst |= 1 << (0 + 4 * chnum);                /* TX_EMPTY */

    omap_mcspi_interrupt_update(s);

    omap_mcspi_dmarequest_update(ch);

}

static void omap_mcspi_reset(struct omap_mcspi_s *s)

{

    int ch;

    s->sysconfig = 0;

    s->systest = 0;

    s->irqst = 0;

    s->irqen = 0;

    s->wken = 0;

    s->control = 4;

    for (ch = 0; ch < 4; ch ++) {

        s->ch[ch].config = 0x060000;

        s->ch[ch].status = 2;                                /* TXS */

        s->ch[ch].control = 0;

        omap_mcspi_dmarequest_update(s->ch + ch);

    }

    omap_mcspi_interrupt_update(s);

}

static uint32_t omap_mcspi_read(void *opaque, target_phys_addr_t addr)

{

    struct omap_mcspi_s *s = (struct omap_mcspi_s *) opaque;

    int ch = 0;

    uint32_t ret;

    switch (addr) {

    case 0x00:        /* MCSPI_REVISION */

        return 0x91;

    case 0x10:        /* MCSPI_SYSCONFIG */

        return s->sysconfig;

    case 0x14:        /* MCSPI_SYSSTATUS */

        return 1;                                        /* RESETDONE */

    case 0x18:        /* MCSPI_IRQSTATUS */

        return s->irqst;

    case 0x1c:        /* MCSPI_IRQENABLE */

        return s->irqen;

    case 0x20:        /* MCSPI_WAKEUPENABLE */

        return s->wken;

    case 0x24:        /* MCSPI_SYST */

        return s->systest;

    case 0x28:        /* MCSPI_MODULCTRL */

        return s->control;

    case 0x68: ch ++;

    case 0x54: ch ++;

    case 0x40: ch ++;

    case 0x2c:        /* MCSPI_CHCONF */

        return s->ch[ch].config;

    case 0x6c: ch ++;

    case 0x58: ch ++;

    case 0x44: ch ++;

    case 0x30:        /* MCSPI_CHSTAT */

        return s->ch[ch].status;

    case 0x70: ch ++;

    case 0x5c: ch ++;

    case 0x48: ch ++;

    case 0x34:        /* MCSPI_CHCTRL */

        return s->ch[ch].control;

    case 0x74: ch ++;

    case 0x60: ch ++;

    case 0x4c: ch ++;

    case 0x38:        /* MCSPI_TX */

        return s->ch[ch].tx;

    case 0x78: ch ++;

    case 0x64: ch ++;

    case 0x50: ch ++;

    case 0x3c:        /* MCSPI_RX */

        s->ch[ch].status &= ~(1 << 0);                        /* RXS */

        ret = s->ch[ch].rx;

        omap_mcspi_transfer_run(s, ch);

        return ret;

    }

    OMAP_BAD_REG(addr);

    return 0;

}

static void omap_mcspi_write(void *opaque, target_phys_addr_t addr,

                uint32_t value)

{

    struct omap_mcspi_s *s = (struct omap_mcspi_s *) opaque;

    int ch = 0;

    switch (addr) {

    case 0x00:        /* MCSPI_REVISION */

    case 0x14:        /* MCSPI_SYSSTATUS */

    case 0x30:        /* MCSPI_CHSTAT0 */

    case 0x3c:        /* MCSPI_RX0 */

    case 0x44:        /* MCSPI_CHSTAT1 */

    case 0x50:        /* MCSPI_RX1 */

    case 0x58:        /* MCSPI_CHSTAT2 */

    case 0x64:        /* MCSPI_RX2 */

    case 0x6c:        /* MCSPI_CHSTAT3 */

    case 0x78:        /* MCSPI_RX3 */

        OMAP_RO_REG(addr);

        return;

    case 0x10:        /* MCSPI_SYSCONFIG */

        if (value & (1 << 1))                                /* SOFTRESET */

            omap_mcspi_reset(s);

        s->sysconfig = value & 0x31d;

        break;

    case 0x18:        /* MCSPI_IRQSTATUS */

        if (!((s->control & (1 << 3)) && (s->systest & (1 << 11)))) {

            s->irqst &= ~value;

            omap_mcspi_interrupt_update(s);

        }

        break;

    case 0x1c:        /* MCSPI_IRQENABLE */

        s->irqen = value & 0x1777f;

        omap_mcspi_interrupt_update(s);

        break;

    case 0x20:        /* MCSPI_WAKEUPENABLE */

        s->wken = value & 1;

        break;

    case 0x24:        /* MCSPI_SYST */

        if (s->control & (1 << 3))                        /* SYSTEM_TEST */

            if (value & (1 << 11)) {                        /* SSB */

                s->irqst |= 0x1777f;

                omap_mcspi_interrupt_update(s);

            }

        s->systest = value & 0xfff;

        break;

    case 0x28:        /* MCSPI_MODULCTRL */

        if (value & (1 << 3))                                /* SYSTEM_TEST */

            if (s->systest & (1 << 11)) {                /* SSB */

                s->irqst |= 0x1777f;

                omap_mcspi_interrupt_update(s);

            }

        s->control = value & 0xf;

        break;

    case 0x68: ch ++;

    case 0x54: ch ++;

    case 0x40: ch ++;

    case 0x2c:        /* MCSPI_CHCONF */

        if ((value ^ s->ch[ch].config) & (3 << 14))        /* DMAR | DMAW */

            omap_mcspi_dmarequest_update(s->ch + ch);

        if (((value >> 12) & 3) == 3)                        /* TRM */

            fprintf(stderr, "%s: invalid TRM value (3)\n", __FUNCTION__);

        if (((value >> 7) & 0x1f) < 3)                        /* WL */

            fprintf(stderr, "%s: invalid WL value (%i)\n",

                            __FUNCTION__, (value >> 7) & 0x1f);

        s->ch[ch].config = value & 0x7fffff;

        break;

    case 0x70: ch ++;

    case 0x5c: ch ++;

    case 0x48: ch ++;

    case 0x34:        /* MCSPI_CHCTRL */

        if (value & ~s->ch[ch].control & 1) {                /* EN */

            s->ch[ch].control |= 1;

            omap_mcspi_transfer_run(s, ch);

        } else

            s->ch[ch].control = value & 1;

        break;

    case 0x74: ch ++;

    case 0x60: ch ++;

    case 0x4c: ch ++;

    case 0x38:        /* MCSPI_TX */

        s->ch[ch].tx = value;

        s->ch[ch].status &= ~(1 << 1);                        /* TXS */

        omap_mcspi_transfer_run(s, ch);

        break;

    default:

        OMAP_BAD_REG(addr);

        return;

    }

}

static CPUReadMemoryFunc * const omap_mcspi_readfn[] = {

    omap_badwidth_read32,

    omap_badwidth_read32,

    omap_mcspi_read,

};

static CPUWriteMemoryFunc * const omap_mcspi_writefn[] = {

    omap_badwidth_write32,

    omap_badwidth_write32,

    omap_mcspi_write,

};

struct omap_mcspi_s *omap_mcspi_init(struct omap_target_agent_s *ta, int chnum,

                qemu_irq irq, qemu_irq *drq, omap_clk fclk, omap_clk iclk)

{

    int iomemtype;

    struct omap_mcspi_s *s = (struct omap_mcspi_s *)

            qemu_mallocz(sizeof(struct omap_mcspi_s));

    struct omap_mcspi_ch_s *ch = s->ch;

    s->irq = irq;

    s->chnum = chnum;

    while (chnum --) {

        ch->txdrq = *drq ++;

        ch->rxdrq = *drq ++;

        ch ++;

    }

    omap_mcspi_reset(s);

    iomemtype = l4_register_io_memory(omap_mcspi_readfn,

                    omap_mcspi_writefn, s);

    omap_l4_attach(ta, 0, iomemtype);

    return s;

}

void omap_mcspi_attach(struct omap_mcspi_s *s,

                uint32_t (*txrx)(void *opaque, uint32_t, int), void *opaque,

                int chipselect)

{

    if (chipselect < 0 || chipselect >= s->chnum)

        hw_error("%s: Bad chipselect %i\n", __FUNCTION__, chipselect);

    s->ch[chipselect].txrx = txrx;

    s->ch[chipselect].opaque = opaque;

}

/* Enhanced Audio Controller (CODEC only) */

struct omap_eac_s {

    qemu_irq irq;

    uint16_t sysconfig;

    uint8_t config[4];

    uint8_t control;

    uint8_t address;

    uint16_t data;

    uint8_t vtol;

    uint8_t vtsl;

    uint16_t mixer;

    uint16_t gain[4];

    uint8_t att;

    uint16_t max[7];

    struct {

        qemu_irq txdrq;

        qemu_irq rxdrq;

        uint32_t (*txrx)(void *opaque, uint32_t, int);

        void *opaque;

#define EAC_BUF_LEN 1024

        uint32_t rxbuf[EAC_BUF_LEN];

        int rxoff;

        int rxlen;

        int rxavail;

        uint32_t txbuf[EAC_BUF_LEN];

        int txlen;

        int txavail;

        int enable;

        int rate;

        uint16_t config[4];

        /* These need to be moved to the actual codec */

        QEMUSoundCard card;

        SWVoiceIn *in_voice;

        SWVoiceOut *out_voice;

        int hw_enable;

    } codec;

    struct {

        uint8_t control;

        uint16_t config;

    } modem, bt;

};

static inline void omap_eac_interrupt_update(struct omap_eac_s *s)

{

    qemu_set_irq(s->irq, (s->codec.config[1] >> 14) & 1);        /* AURDI */

}

static inline void omap_eac_in_dmarequest_update(struct omap_eac_s *s)

{

    qemu_set_irq(s->codec.rxdrq, (s->codec.rxavail || s->codec.rxlen) &&

                    ((s->codec.config[1] >> 12) & 1));                /* DMAREN */

}

static inline void omap_eac_out_dmarequest_update(struct omap_eac_s *s)

{

    qemu_set_irq(s->codec.txdrq, s->codec.txlen < s->codec.txavail &&

                    ((s->codec.config[1] >> 11) & 1));                /* DMAWEN */

}

static inline void omap_eac_in_refill(struct omap_eac_s *s)

{

    int left = MIN(EAC_BUF_LEN - s->codec.rxlen, s->codec.rxavail) << 2;

    int start = ((s->codec.rxoff + s->codec.rxlen) & (EAC_BUF_LEN - 1)) << 2;

    int leftwrap = MIN(left, (EAC_BUF_LEN << 2) - start);

    int recv = 1;

    uint8_t *buf = (uint8_t *) s->codec.rxbuf + start;

    left -= leftwrap;

    start = 0;

    while (leftwrap && (recv = AUD_read(s->codec.in_voice, buf + start,

                                    leftwrap)) > 0) {        /* Be defensive */

        start += recv;

        leftwrap -= recv;

    }

    if (recv <= 0)

        s->codec.rxavail = 0;

    else

        s->codec.rxavail -= start >> 2;

    s->codec.rxlen += start >> 2;

    if (recv > 0 && left > 0) {

        start = 0;

        while (left && (recv = AUD_read(s->codec.in_voice,

                                        (uint8_t *) s->codec.rxbuf + start,

                                        left)) > 0) {        /* Be defensive */

            start += recv;

            left -= recv;

        }

        if (recv <= 0)

            s->codec.rxavail = 0;

        else

            s->codec.rxavail -= start >> 2;

        s->codec.rxlen += start >> 2;

    }

}

static inline void omap_eac_out_empty(struct omap_eac_s *s)

{

    int left = s->codec.txlen << 2;

    int start = 0;

    int sent = 1;

    while (left && (sent = AUD_write(s->codec.out_voice,

                                    (uint8_t *) s->codec.txbuf + start,

                                    left)) > 0) {        /* Be defensive */

        start += sent;

        left -= sent;

    }

    if (!sent) {

        s->codec.txavail = 0;

        omap_eac_out_dmarequest_update(s);

    }

    if (start)

        s->codec.txlen = 0;

}

static void omap_eac_in_cb(void *opaque, int avail_b)

{

    struct omap_eac_s *s = (struct omap_eac_s *) opaque;

    s->codec.rxavail = avail_b >> 2;

    omap_eac_in_refill(s);

    /* TODO: possibly discard current buffer if overrun */

    omap_eac_in_dmarequest_update(s);

}

static void omap_eac_out_cb(void *opaque, int free_b)

{

    struct omap_eac_s *s = (struct omap_eac_s *) opaque;

    s->codec.txavail = free_b >> 2;

    if (s->codec.txlen)

        omap_eac_out_empty(s);

    else

        omap_eac_out_dmarequest_update(s);

}

static void omap_eac_enable_update(struct omap_eac_s *s)

{

    s->codec.enable = !(s->codec.config[1] & 1) &&                /* EACPWD */

            (s->codec.config[1] & 2) &&                                /* AUDEN */

            s->codec.hw_enable;

}

static const int omap_eac_fsint[4] = {

    8000,

    11025,

    22050,

    44100,

};

static const int omap_eac_fsint2[8] = {

    8000,

    11025,

    22050,

    44100,

    48000,

    0, 0, 0,

};

static const int omap_eac_fsint3[16] = {

    8000,

    11025,

    16000,

    22050,

    24000,

    32000,

    44100,

    48000,

    0, 0, 0, 0, 0, 0, 0, 0,

};

static void omap_eac_rate_update(struct omap_eac_s *s)

{

    int fsint[3];

    fsint[2] = (s->codec.config[3] >> 9) & 0xf;

    fsint[1] = (s->codec.config[2] >> 0) & 0x7;

    fsint[0] = (s->codec.config[0] >> 6) & 0x3;

    if (fsint[2] < 0xf)

        s->codec.rate = omap_eac_fsint3[fsint[2]];

    else if (fsint[1] < 0x7)

        s->codec.rate = omap_eac_fsint2[fsint[1]];

    else

        s->codec.rate = omap_eac_fsint[fsint[0]];

}

static void omap_eac_volume_update(struct omap_eac_s *s)

{

    /* TODO */

}

static void omap_eac_format_update(struct omap_eac_s *s)

{

    struct audsettings fmt;

    /* The hardware buffers at most one sample */

    if (s->codec.rxlen)

        s->codec.rxlen = 1;

    if (s->codec.in_voice) {

        AUD_set_active_in(s->codec.in_voice, 0);

        AUD_close_in(&s->codec.card, s->codec.in_voice);

        s->codec.in_voice = NULL;

    }

    if (s->codec.out_voice) {

        omap_eac_out_empty(s);

        AUD_set_active_out(s->codec.out_voice, 0);

        AUD_close_out(&s->codec.card, s->codec.out_voice);

        s->codec.out_voice = NULL;

        s->codec.txavail = 0;

    }

    /* Discard what couldn't be written */

    s->codec.txlen = 0;

    omap_eac_enable_update(s);

    if (!s->codec.enable)

        return;

    omap_eac_rate_update(s);

    fmt.endianness = ((s->codec.config[0] >> 8) & 1);                /* LI_BI */

    fmt.nchannels = ((s->codec.config[0] >> 10) & 1) ? 2 : 1;        /* MN_ST */

    fmt.freq = s->codec.rate;

    /* TODO: signedness possibly depends on the CODEC hardware - or

     * does I2S specify it?  */

    /* All register writes are 16 bits so we we store 16-bit samples

     * in the buffers regardless of AGCFR[B8_16] value.  */

    fmt.fmt = AUD_FMT_U16;

    s->codec.in_voice = AUD_open_in(&s->codec.card, s->codec.in_voice,

                    "eac.codec.in", s, omap_eac_in_cb, &fmt);

    s->codec.out_voice = AUD_open_out(&s->codec.card, s->codec.out_voice,

                    "eac.codec.out", s, omap_eac_out_cb, &fmt);

    omap_eac_volume_update(s);

    AUD_set_active_in(s->codec.in_voice, 1);

    AUD_set_active_out(s->codec.out_voice, 1);

}

static void omap_eac_reset(struct omap_eac_s *s)

{

    s->sysconfig = 0;

    s->config[0] = 0x0c;

    s->config[1] = 0x09;

    s->config[2] = 0xab;

    s->config[3] = 0x03;

    s->control = 0x00;

    s->address = 0x00;

    s->data = 0x0000;

    s->vtol = 0x00;

    s->vtsl = 0x00;

    s->mixer = 0x0000;

    s->gain[0] = 0xe7e7;

    s->gain[1] = 0x6767;

    s->gain[2] = 0x6767;

    s->gain[3] = 0x6767;

    s->att = 0xce;

    s->max[0] = 0;

    s->max[1] = 0;

    s->max[2] = 0;

    s->max[3] = 0;

    s->max[4] = 0;

    s->max[5] = 0;

    s->max[6] = 0;

    s->modem.control = 0x00;

    s->modem.config = 0x0000;

    s->bt.control = 0x00;

    s->bt.config = 0x0000;

    s->codec.config[0] = 0x0649;

    s->codec.config[1] = 0x0000;

    s->codec.config[2] = 0x0007;

    s->codec.config[3] = 0x1ffc;

    s->codec.rxoff = 0;

    s->codec.rxlen = 0;

    s->codec.txlen = 0;

    s->codec.rxavail = 0;

    s->codec.txavail = 0;

    omap_eac_format_update(s);

    omap_eac_interrupt_update(s);

}

static uint32_t omap_eac_read(void *opaque, target_phys_addr_t addr)

{

    struct omap_eac_s *s = (struct omap_eac_s *) opaque;

    uint32_t ret;

    switch (addr) {

    case 0x000:        /* CPCFR1 */

        return s->config[0];

    case 0x004:        /* CPCFR2 */

        return s->config[1];

    case 0x008:        /* CPCFR3 */

        return s->config[2];

    case 0x00c:        /* CPCFR4 */

        return s->config[3];

    case 0x010:        /* CPTCTL */

        return s->control | ((s->codec.rxavail + s->codec.rxlen > 0) << 7) |

                ((s->codec.txlen < s->codec.txavail) << 5);

    case 0x014:        /* CPTTADR */

        return s->address;

    case 0x018:        /* CPTDATL */

        return s->data & 0xff;

    case 0x01c:        /* CPTDATH */

        return s->data >> 8;

    case 0x020:        /* CPTVSLL */

        return s->vtol;

    case 0x024:        /* CPTVSLH */

        return s->vtsl | (3 << 5);        /* CRDY1 | CRDY2 */

    case 0x040:        /* MPCTR */

        return s->modem.control;

    case 0x044:        /* MPMCCFR */

        return s->modem.config;

    case 0x060:        /* BPCTR */

        return s->bt.control;

    case 0x064:        /* BPMCCFR */

        return s->bt.config;

    case 0x080:        /* AMSCFR */

        return s->mixer;

    case 0x084:        /* AMVCTR */

        return s->gain[0];

    case 0x088:        /* AM1VCTR */

        return s->gain[1];

    case 0x08c:        /* AM2VCTR */

        return s->gain[2];

    case 0x090:        /* AM3VCTR */

        return s->gain[3];

    case 0x094:        /* ASTCTR */

        return s->att;

    case 0x098:        /* APD1LCR */

        return s->max[0];

    case 0x09c:        /* APD1RCR */

        return s->max[1];

    case 0x0a0:        /* APD2LCR */

        return s->max[2];

    case 0x0a4:        /* APD2RCR */

        return s->max[3];

    case 0x0a8:        /* APD3LCR */

        return s->max[4];

    case 0x0ac:        /* APD3RCR */

        return s->max[5];

    case 0x0b0:        /* APD4R */

        return s->max[6];

    case 0x0b4:        /* ADWR */

        /* This should be write-only?  Docs list it as read-only.  */

        return 0x0000;

    case 0x0b8:        /* ADRDR */

        if (likely(s->codec.rxlen > 1)) {

            ret = s->codec.rxbuf[s->codec.rxoff ++];

            s->codec.rxlen --;

            s->codec.rxoff &= EAC_BUF_LEN - 1;

            return ret;

        } else if (s->codec.rxlen) {

            ret = s->codec.rxbuf[s->codec.rxoff ++];

            s->codec.rxlen --;

            s->codec.rxoff &= EAC_BUF_LEN - 1;

            if (s->codec.rxavail)

                omap_eac_in_refill(s);

            omap_eac_in_dmarequest_update(s);

            return ret;

        }

        return 0x0000;

    case 0x0bc:        /* AGCFR */

        return s->codec.config[0];

    case 0x0c0:        /* AGCTR */

        return s->codec.config[1] | ((s->codec.config[1] & 2) << 14);

    case 0x0c4:        /* AGCFR2 */

        return s->codec.config[2];

    case 0x0c8:        /* AGCFR3 */

        return s->codec.config[3];

    case 0x0cc:        /* MBPDMACTR */

    case 0x0d0:        /* MPDDMARR */

    case 0x0d8:        /* MPUDMARR */

    case 0x0e4:        /* BPDDMARR */

    case 0x0ec:        /* BPUDMARR */

        return 0x0000;

    case 0x100:        /* VERSION_NUMBER */

        return 0x0010;

    case 0x104:        /* SYSCONFIG */

        return s->sysconfig;

    case 0x108:        /* SYSSTATUS */

        return 1 | 0xe;                                        /* RESETDONE | stuff */

    }

    OMAP_BAD_REG(addr);

    return 0;

}

static void omap_eac_write(void *opaque, target_phys_addr_t addr,

                uint32_t value)

{

    struct omap_eac_s *s = (struct omap_eac_s *) opaque;

    switch (addr) {

    case 0x098:        /* APD1LCR */

    case 0x09c:        /* APD1RCR */

    case 0x0a0:        /* APD2LCR */

    case 0x0a4:        /* APD2RCR */

    case 0x0a8:        /* APD3LCR */

    case 0x0ac:        /* APD3RCR */

    case 0x0b0:        /* APD4R */

    case 0x0b8:        /* ADRDR */

    case 0x0d0:        /* MPDDMARR */

    case 0x0d8:        /* MPUDMARR */

    case 0x0e4:        /* BPDDMARR */

    case 0x0ec:        /* BPUDMARR */

    case 0x100:        /* VERSION_NUMBER */

    case 0x108:        /* SYSSTATUS */

        OMAP_RO_REG(addr);

        return;

    case 0x000:        /* CPCFR1 */

        s->config[0] = value & 0xff;

        omap_eac_format_update(s);

        break;

    case 0x004:        /* CPCFR2 */

        s->config[1] = value & 0xff;

        omap_eac_format_update(s);

        break;

    case 0x008:        /* CPCFR3 */

        s->config[2] = value & 0xff;

        omap_eac_format_update(s);

        break;

    case 0x00c:        /* CPCFR4 */

        s->config[3] = value & 0xff;

        omap_eac_format_update(s);

        break;

    case 0x010:        /* CPTCTL */

        /* Assuming TXF and TXE bits are read-only... */

        s->control = value & 0x5f;

        omap_eac_interrupt_update(s);

        break;

    case 0x014:        /* CPTTADR */

        s->address = value & 0xff;

        break;

    case 0x018:        /* CPTDATL */

        s->data &= 0xff00;

        s->data |= value & 0xff;

        break;

    case 0x01c:        /* CPTDATH */

        s->data &= 0x00ff;

        s->data |= value << 8;

        break;

    case 0x020:        /* CPTVSLL */

        s->vtol = value & 0xf8;

        break;

    case 0x024:        /* CPTVSLH */

        s->vtsl = value & 0x9f;

        break;

    case 0x040:        /* MPCTR */

        s->modem.control = value & 0x8f;

        break;

    case 0x044:        /* MPMCCFR */

        s->modem.config = value & 0x7fff;

        break;

    case 0x060:        /* BPCTR */

        s->bt.control = value & 0x8f;

        break;

    case 0x064:        /* BPMCCFR */

        s->bt.config = value & 0x7fff;

        break;

    case 0x080:        /* AMSCFR */

        s->mixer = value & 0x0fff;

        break;

    case 0x084:        /* AMVCTR */

        s->gain[0] = value & 0xffff;

        break;

    case 0x088:        /* AM1VCTR */

        s->gain[1] = value & 0xff7f;

        break;

    case 0x08c:        /* AM2VCTR */

        s->gain[2] = value & 0xff7f;

        break;

    case 0x090:        /* AM3VCTR */

        s->gain[3] = value & 0xff7f;

        break;

    case 0x094:        /* ASTCTR */