← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/linaro-patches-1.5.0/0032-fix-omap_spi-rxs-flag-status-update.patch/hw/ssi/omap_spi.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/linaro-patches-1.5.0/0032-fix-omap_spi-rxs-flag-status-update.patch/hw/ssi/omap_spi.c
1
 
/*
2
 
 * TI OMAP processor's Multichannel SPI emulation.
3
 
 *
4
 
 * Copyright (C) 2007-2009 Nokia Corporation
5
 
 *
6
 
 * Original code for OMAP2 by Andrzej Zaborowski <andrew@openedhand.com>
7
 
 *
8
 
 * This program is free software; you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation; either version 2 or
11
 
 * (at your option) any later version of the License.
12
 
 *
13
 
 * This program is distributed in the hope that it will be useful,
14
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
 * GNU General Public License for more details.
17
 
 *
18
 
 * You should have received a copy of the GNU General Public License along
19
 
 * with this program; if not, write to the Free Software Foundation, Inc.,
20
 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21
 
 */
22
 
#include "hw/hw.h"
23
 
#include "hw/arm/omap.h"
24
 
#include "hw/sysbus.h"
25
 
#include "hw/spi.h"
26
 
 
27
 
//#define SPI_DEBUG
28
 
 
29
 
#ifdef SPI_DEBUG
30
 
#define TRACE(fmt,...) fprintf(stderr, "%s@%d: " fmt "\n", __FUNCTION__, \
31
 
                               __LINE__, ##__VA_ARGS__);
32
 
#else
33
 
#define TRACE(...)
34
 
#endif
35
 
 
36
 
#define SPI_FIFOSIZE 64
37
 
#define SPI_REV_OMAP2420 0x14
38
 
#define SPI_REV_OMAP3430 0x21
39
 
#define IS_OMAP3_SPI(s) ((s)->revision >= SPI_REV_OMAP3430)
40
 
 
41
 
typedef struct omap_mcspi_bus_s {
42
 
    SPIBus *bus;
43
 
    MemoryRegion iomem;
44
 
    qemu_irq irq;
45
 
    int chnum;
46
 
    uint8_t revision;
47
 
 
48
 
    uint32_t sysconfig;
49
 
    uint32_t systest;
50
 
    uint32_t irqst;
51
 
    uint32_t irqen;
52
 
    uint32_t wken;
53
 
    uint32_t control;
54
 
 
55
 
    uint32_t xferlevel;
56
 
    struct omap_mcspi_fifo_s {
57
 
        int start;
58
 
        int len;
59
 
        int size;
60
 
        uint8_t buf[SPI_FIFOSIZE];
61
 
    } tx_fifo, rx_fifo;
62
 
    int fifo_ch;
63
 
    int fifo_wcnt;
64
 
 
65
 
    struct omap_mcspi_ch_s {
66
 
        qemu_irq txdrq;
67
 
        qemu_irq rxdrq;
68
 
 
69
 
        uint32_t tx;
70
 
        uint32_t rx;
71
 
 
72
 
        uint32_t config;
73
 
        uint32_t status;
74
 
        uint32_t control;
75
 
    } *ch;
76
 
} OMAPSPIBusState;
77
 
 
78
 
typedef struct omap_mcspi_s {
79
 
    SysBusDevice busdev;
80
 
    int mpu_model;
81
 
    int buscount;
82
 
    OMAPSPIBusState *bus;
83
 
} OMAPSPIState;
84
 
 
85
 
static inline void omap_mcspi_interrupt_update(OMAPSPIBusState *s)
86
 
{
87
 
    qemu_set_irq(s->irq, s->irqst & s->irqen);
88
 
}
89
 
 
90
 
static inline void omap_mcspi_dmarequest_update(OMAPSPIBusState *s,
91
 
                                                int chnum)
92
 
{
93
 
    struct omap_mcspi_ch_s *ch = &s->ch[chnum];
94
 
    if ((ch->control & 1) &&                         /* EN */
95
 
        (ch->config & (1 << 14)) &&                  /* DMAW */
96
 
        (ch->status & (1 << 1)) &&                   /* TXS */
97
 
        ((ch->config >> 12) & 3) != 1) {             /* TRM */
98
 
        if (!IS_OMAP3_SPI(s) ||
99
 
            !(ch->config & (1 << 27)) ||             /* FFEW */
100
 
            s->tx_fifo.len <= (s->xferlevel & 0x3f)) /* AEL */
101
 
            qemu_irq_raise(ch->txdrq);
102
 
        else
103
 
            qemu_irq_lower(ch->txdrq);
104
 
    }
105
 
    if ((ch->control & 1) &&                                /* EN */
106
 
        (ch->config & (1 << 15)) &&                         /* DMAW */
107
 
        (ch->status & (1 << 0)) &&                          /* RXS */
108
 
        ((ch->config >> 12) & 3) != 2) {                    /* TRM */
109
 
        if (!IS_OMAP3_SPI(s) ||
110
 
            !(ch->config & (1 << 28)) ||                    /* FFER */
111
 
            s->rx_fifo.len >= ((s->xferlevel >> 8) & 0x3f)) /* AFL */
112
 
            qemu_irq_raise(ch->rxdrq);
113
 
        else
114
 
            qemu_irq_lower(ch->rxdrq);
115
 
    }
116
 
}
117
 
 
118
 
static void omap_mcspi_fifo_reset(OMAPSPIBusState *s)
119
 
{
120
 
    struct omap_mcspi_ch_s *ch;
121
 
 
122
 
    s->tx_fifo.len = 0;
123
 
    s->rx_fifo.len = 0;
124
 
    s->tx_fifo.start = 0;
125
 
    s->rx_fifo.start = 0;
126
 
    if (s->fifo_ch < 0) {
127
 
        s->tx_fifo.size  = s->rx_fifo.size  = 0;
128
 
    } else {
129
 
        ch = &s->ch[s->fifo_ch];
130
 
        s->tx_fifo.size = ((ch->config >> 27) & 1) ? SPI_FIFOSIZE : 0;
131
 
        s->rx_fifo.size = ((ch->config >> 28) & 1) ? SPI_FIFOSIZE : 0;
132
 
        if (((ch->config >> 27) & 3) == 3) {
133
 
            s->tx_fifo.size >>= 1;
134
 
            s->rx_fifo.size >>= 1;
135
 
        }
136
 
    }
137
 
}
138
 
 
139
 
/* returns next word in FIFO or the n first bytes if there is not
140
 
 * enough data in FIFO */
141
 
static uint32_t omap_mcspi_fifo_get(struct omap_mcspi_fifo_s *s, int wl)
142
 
{
143
 
    uint32_t v, sh;
144
 
 
145
 
    for (v = 0, sh = 0; wl > 0 && s->len; wl -= 8, s->len--, sh += 8) {
146
 
        v |= ((uint32_t)s->buf[s->start++]) << sh;
147
 
        if (s->start >= s->size)
148
 
            s->start = 0;
149
 
    }
150
 
    return v;
151
 
}
152
 
 
153
 
/* pushes a word to FIFO or the first n bytes of the word if the FIFO
154
 
 * is too full to hold the full word */
155
 
static void omap_mcspi_fifo_put(struct omap_mcspi_fifo_s *s, int wl,
156
 
                                uint32_t v)
157
 
{
158
 
    int p = s->start + s->len;
159
 
 
160
 
    for (; wl > 0 && s->len < s->size; wl -=8, v >>= 8, s->len++) {
161
 
        if (p >= s->size)
162
 
            p -= s->size;
163
 
        s->buf[p++] = (uint8_t)(v & 0xff);
164
 
    }
165
 
}
166
 
 
167
 
static void omap_mcspi_transfer_run(OMAPSPIBusState *s, int chnum)
168
 
{
169
 
    struct omap_mcspi_ch_s *ch = s->ch + chnum;
170
 
    int trm = (ch->config >> 12) & 3;
171
 
    int wl;
172
 
 
173
 
    if (!(ch->control & 1))                  /* EN */
174
 
        return;
175
 
    if ((ch->status & 1) && trm != 2 &&      /* RXS */
176
 
        !(ch->config & (1 << 19)))           /* TURBO */
177
 
        goto intr_update;
178
 
    if ((ch->status & (1 << 1)) && trm != 1) /* TXS */
179
 
        goto intr_update;
180
 
 
181
 
    if (!(s->control & 1) ||        /* SINGLE */
182
 
        (ch->config & (1 << 20))) { /* FORCE */
183
 
        wl = 1 + (0x1f & (ch->config >> 7)); /* WL */
184
 
        if (!IS_OMAP3_SPI(s) || s->fifo_ch != chnum ||
185
 
            !((ch->config >> 27) & 3)) {     /* FFER | FFEW */
186
 
            ch->rx = spi_txrx(s->bus, chnum, ch->tx, wl);
187
 
        } else {
188
 
            switch ((ch->config >> 27) & 3) {
189
 
            case 1: /* !FFER, FFEW */
190
 
                if (trm != 1)
191
 
                    ch->tx = omap_mcspi_fifo_get(&s->tx_fifo, wl);
192
 
                ch->rx = spi_txrx(s->bus, chnum, ch->tx, wl);
193
 
                s->fifo_wcnt--;
194
 
                break;
195
 
            case 2: /* FFER, !FFEW */
196
 
                ch->rx = spi_txrx(s->bus, chnum, ch->tx, wl);
197
 
                if (trm != 2)
198
 
                    omap_mcspi_fifo_put(&s->rx_fifo, wl, ch->rx);
199
 
                s->fifo_wcnt--;
200
 
                break;
201
 
            case 3: /* FFER, FFEW */
202
 
                while (s->rx_fifo.len < s->rx_fifo.size &&
203
 
                       s->tx_fifo.len && s->fifo_wcnt) {
204
 
                    if (trm != 1)
205
 
                        ch->tx = omap_mcspi_fifo_get(&s->tx_fifo, wl);
206
 
                    ch->rx = spi_txrx(s->bus, chnum, ch->tx, wl);
207
 
                    if (trm != 2)
208
 
                        omap_mcspi_fifo_put(&s->rx_fifo, wl, ch->rx);
209
 
                    s->fifo_wcnt--;
210
 
                }
211
 
                break;
212
 
            default:
213
 
                break;
214
 
            }
215
 
            if ((ch->config & (1 << 28)) &&        /* FFER */
216
 
                s->rx_fifo.len >= s->rx_fifo.size)
217
 
                ch->status |= 1 << 6;              /* RXFFF */
218
 
            ch->status &= ~(1 << 5);               /* RXFFE */
219
 
            ch->status &= ~(1 << 4);               /* TXFFF */
220
 
            if ((ch->config & (1 << 27)) &&        /* FFEW */
221
 
                !s->tx_fifo.len)
222
 
                ch->status |= 1 << 3;              /* TXFFE */
223
 
            if (!s->fifo_wcnt &&
224
 
                ((s->xferlevel >> 16) & 0xffff))   /* WCNT */
225
 
                s->irqst |= 1 << 17;               /* EOW */
226
 
        }
227
 
    }
228
 
 
229
 
    ch->tx = 0;
230
 
    ch->status |= 1 << 2;               /* EOT */
231
 
    ch->status |= 1 << 1;               /* TXS */
232
 
    if (trm != 2)
233
 
        ch->status |= 1;                /* RXS */
234
 
 
235
 
intr_update:
236
 
    if ((ch->status & 1) &&     trm != 2 &&                     /* RXS */
237
 
        !(ch->config & (1 << 19)))                          /* TURBO */
238
 
        if (!IS_OMAP3_SPI(s) || s->fifo_ch != chnum ||
239
 
            !((ch->config >> 28) & 1) ||                    /* FFER */
240
 
            s->rx_fifo.len >= ((s->xferlevel >> 8) & 0x3f)) /* AFL */
241
 
            s->irqst |= 1 << (2 + 4 * chnum);               /* RX_FULL */
242
 
    if ((ch->status & (1 << 1)) && trm != 1)                /* TXS */
243
 
        if (!IS_OMAP3_SPI(s) || s->fifo_ch != chnum ||
244
 
            !((ch->config >> 27) & 1) ||                    /* FFEW */
245
 
            s->tx_fifo.len <= (s->xferlevel & 0x3f))        /* AEL */
246
 
            s->irqst |= 1 << (4 * chnum);                   /* TX_EMPTY */
247
 
    omap_mcspi_interrupt_update(s);
248
 
    omap_mcspi_dmarequest_update(s, chnum);
249
 
}
250
 
 
251
 
static void omap_mcspi_bus_reset(OMAPSPIBusState *s)
252
 
{
253
 
    int ch;
254
 
 
255
 
    s->sysconfig = 0;
256
 
    s->systest = 0;
257
 
    s->irqst = 0;
258
 
    s->irqen = 0;
259
 
    s->wken = 0;
260
 
    s->control = 4;
261
 
 
262
 
    s->fifo_ch = -1;
263
 
    omap_mcspi_fifo_reset(s);
264
 
 
265
 
    for (ch = 0; ch < s->chnum; ch ++) {
266
 
        s->ch[ch].config = 0x060000;
267
 
        s->ch[ch].status = 2;                           /* TXS */
268
 
        s->ch[ch].control = 0;
269
 
 
270
 
        omap_mcspi_dmarequest_update(s, ch);
271
 
    }
272
 
 
273
 
    omap_mcspi_interrupt_update(s);
274
 
}
275
 
 
276
 
static uint64_t omap_mcspi_read(void *opaque, hwaddr addr,
277
 
                                unsigned size)
278
 
{
279
 
    OMAPSPIBusState *s = (OMAPSPIBusState *) opaque;
280
 
    int ch = 0;
281
 
    uint32_t ret;
282
 
 
283
 
    if (size != 4) {
284
 
        return omap_badwidth_read32(opaque, addr);
285
 
    }
286
 
 
287
 
    switch (addr) {
288
 
    case 0x00:  /* MCSPI_REVISION */
289
 
        TRACE("REVISION = 0x%08x", s->revision);
290
 
        return s->revision;
291
 
 
292
 
    case 0x10:  /* MCSPI_SYSCONFIG */
293
 
        TRACE("SYSCONFIG = 0x%08x", s->sysconfig);
294
 
        return s->sysconfig;
295
 
 
296
 
    case 0x14:  /* MCSPI_SYSSTATUS */
297
 
        TRACE("SYSSTATUS = 0x00000001");
298
 
        return 1;                                       /* RESETDONE */
299
 
 
300
 
    case 0x18:  /* MCSPI_IRQSTATUS */
301
 
        TRACE("IRQSTATUS = 0x%08x", s->irqst);
302
 
        return s->irqst;
303
 
 
304
 
    case 0x1c:  /* MCSPI_IRQENABLE */
305
 
        TRACE("IRQENABLE = 0x%08x", s->irqen);
306
 
        return s->irqen;
307
 
 
308
 
    case 0x20:  /* MCSPI_WAKEUPENABLE */
309
 
        TRACE("WAKEUPENABLE = 0x%08x", s->wken);
310
 
        return s->wken;
311
 
 
312
 
    case 0x24:  /* MCSPI_SYST */
313
 
        TRACE("SYST = 0x%08x", s->systest);
314
 
        return s->systest;
315
 
 
316
 
    case 0x28:  /* MCSPI_MODULCTRL */
317
 
        TRACE("MODULCTRL = 0x%08x", s->control);
318
 
        return s->control;
319
 
 
320
 
    case 0x68: ch ++;
321
 
        /* fall through */
322
 
    case 0x54: ch ++;
323
 
        /* fall through */
324
 
    case 0x40: ch ++;
325
 
        /* fall through */
326
 
    case 0x2c:  /* MCSPI_CHCONF */
327
 
        TRACE("CHCONF%d = 0x%08x", ch,
328
 
              (ch < s->chnum) ? s->ch[ch].config : 0);
329
 
        return (ch < s->chnum) ? s->ch[ch].config : 0;
330
 
 
331
 
    case 0x6c: ch ++;
332
 
        /* fall through */
333
 
    case 0x58: ch ++;
334
 
        /* fall through */
335
 
    case 0x44: ch ++;
336
 
        /* fall through */
337
 
    case 0x30:  /* MCSPI_CHSTAT */
338
 
        TRACE("CHSTAT%d = 0x%08x", ch,
339
 
              (ch < s->chnum) ? s->ch[ch].status : 0);
340
 
        return (ch < s->chnum) ? s->ch[ch].status : 0;
341
 
 
342
 
    case 0x70: ch ++;
343
 
        /* fall through */
344
 
    case 0x5c: ch ++;
345
 
        /* fall through */
346
 
    case 0x48: ch ++;
347
 
        /* fall through */
348
 
    case 0x34:  /* MCSPI_CHCTRL */
349
 
        TRACE("CHCTRL%d = 0x%08x", ch,
350
 
              (ch < s->chnum) ? s->ch[ch].control : 0);
351
 
        return (ch < s->chnum) ? s->ch[ch].control : 0;
352
 
 
353
 
    case 0x74: ch ++;
354
 
        /* fall through */
355
 
    case 0x60: ch ++;
356
 
        /* fall through */
357
 
    case 0x4c: ch ++;
358
 
        /* fall through */
359
 
    case 0x38:  /* MCSPI_TX */
360
 
        TRACE("TX%d = 0x%08x", ch,
361
 
              (ch < s->chnum) ? s->ch[ch].tx : 0);
362
 
        return (ch < s->chnum) ? s->ch[ch].tx : 0;
363
 
 
364
 
    case 0x78: ch ++;
365
 
        /* fall through */
366
 
    case 0x64: ch ++;
367
 
        /* fall through */
368
 
    case 0x50: ch ++;
369
 
        /* fall through */
370
 
    case 0x3c:  /* MCSPI_RX */
371
 
        if (ch < s->chnum) {
372
 
            if (!IS_OMAP3_SPI(s) || ch != s->fifo_ch ||
373
 
                !(s->ch[ch].config & (1 << 28))) { /* FFER */
374
 
                s->ch[ch].status &= ~1;            /* RXS */
375
 
                ret = s->ch[ch].rx;
376
 
                TRACE("RX%d = 0x%08x", ch, ret);
377
 
                omap_mcspi_transfer_run(s, ch);
378
 
                return ret;
379
 
            }
380
 
            if (!s->rx_fifo.len) {
381
 
                TRACE("rxfifo underflow!");
382
 
            } else {
383
 
                qemu_irq_lower(s->ch[ch].rxdrq);
384
 
                s->ch[ch].status &= ~(1 << 6);                 /* RXFFF */
385
 
                if (((s->ch[ch].config >> 12) & 3) != 2)        /* TRM */
386
 
                    ret = omap_mcspi_fifo_get(&s->rx_fifo,
387
 
                        1 + ((s->ch[ch].config >> 7) & 0x1f)); /* WL */
388
 
                else
389
 
                    ret = s->ch[ch].rx;
390
 
                TRACE("RX%d = 0x%08x", ch, ret);
391
 
                if (!s->rx_fifo.len) {
392
 
                    s->ch[ch].status &= ~1;     /* RXS */
393
 
                    s->ch[ch].status |= 1 << 5; /* RXFFE */
394
 
                    omap_mcspi_transfer_run(s, ch);
395
 
                }
396
 
                return ret;
397
 
            }
398
 
        }
399
 
        TRACE("RX%d = 0x00000000", ch);
400
 
        return 0;
401
 
 
402
 
    case 0x7c: /* MCSPI_XFERLEVEL */
403
 
        if (IS_OMAP3_SPI(s)) {
404
 
            if ((s->xferlevel >> 16) & 0xffff) /* WCNT */
405
 
                ret = ((s->xferlevel & 0xffff0000) - (s->fifo_wcnt << 16));
406
 
            else
407
 
                ret = ((-s->fifo_wcnt) & 0xffff) << 16;
408
 
            TRACE("XFERLEVEL = 0x%08x", (s->xferlevel & 0xffff) | ret);
409
 
            return (s->xferlevel & 0xffff) | ret;
410
 
        }
411
 
        break;
412
 
 
413
 
    default:
414
 
        break;
415
 
    }
416
 
 
417
 
    OMAP_BAD_REG(addr);
418
 
    return 0;
419
 
}
420
 
 
421
 
static void omap_mcspi_write(void *opaque, hwaddr addr,
422
 
                             uint64_t value, unsigned size)
423
 
{
424
 
    OMAPSPIBusState *s = (OMAPSPIBusState *) opaque;
425
 
    uint32_t old;
426
 
    int ch = 0;
427
 
 
428
 
    if (size != 4) {
429
 
        return omap_badwidth_write32(opaque, addr, value);
430
 
    }
431
 
 
432
 
    switch (addr) {
433
 
    case 0x00:  /* MCSPI_REVISION */
434
 
    case 0x14:  /* MCSPI_SYSSTATUS */
435
 
    case 0x30:  /* MCSPI_CHSTAT0 */
436
 
    case 0x3c:  /* MCSPI_RX0 */
437
 
    case 0x44:  /* MCSPI_CHSTAT1 */
438
 
    case 0x50:  /* MCSPI_RX1 */
439
 
    case 0x58:  /* MCSPI_CHSTAT2 */
440
 
    case 0x64:  /* MCSPI_RX2 */
441
 
    case 0x6c:  /* MCSPI_CHSTAT3 */
442
 
    case 0x78:  /* MCSPI_RX3 */
443
 
        /* silently ignore */
444
 
        //OMAP_RO_REGV(addr, value);
445
 
        return;
446
 
 
447
 
    case 0x10:  /* MCSPI_SYSCONFIG */
448
 
        TRACE("SYSCONFIG = 0x%08x", value);
449
 
        if (value & (1 << 1))                           /* SOFTRESET */
450
 
            omap_mcspi_bus_reset(s);
451
 
        s->sysconfig = value & 0x31d;
452
 
        break;
453
 
 
454
 
    case 0x18:  /* MCSPI_IRQSTATUS */
455
 
        TRACE("IRQSTATUS = 0x%08x", value);
456
 
        if (!((s->control & (1 << 3)) && (s->systest & (1 << 11)))) {
457
 
            s->irqst &= ~value;
458
 
            omap_mcspi_interrupt_update(s);
459
 
        }
460
 
        break;
461
 
 
462
 
    case 0x1c:  /* MCSPI_IRQENABLE */
463
 
        TRACE("IRQENABLE = 0x%08x", value);
464
 
        s->irqen = value & (IS_OMAP3_SPI(s) ? 0x3777f : 0x1777f);
465
 
        omap_mcspi_interrupt_update(s);
466
 
        break;
467
 
 
468
 
    case 0x20:  /* MCSPI_WAKEUPENABLE */
469
 
        TRACE("WAKEUPENABLE = 0x%08x", value);
470
 
        s->wken = value & 1;
471
 
        break;
472
 
 
473
 
    case 0x24:  /* MCSPI_SYST */
474
 
        TRACE("SYST = 0x%08x", value);
475
 
        if (s->control & (1 << 3))                      /* SYSTEM_TEST */
476
 
            if (value & (1 << 11)) {                    /* SSB */
477
 
                s->irqst |= 0x1777f;
478
 
                omap_mcspi_interrupt_update(s);
479
 
            }
480
 
        s->systest = value & 0xfff;
481
 
        break;
482
 
 
483
 
    case 0x28:  /* MCSPI_MODULCTRL */
484
 
        TRACE("MODULCTRL = 0x%08x", value);
485
 
        if (value & (1 << 3))                           /* SYSTEM_TEST */
486
 
            if (s->systest & (1 << 11)) {               /* SSB */
487
 
                s->irqst |= IS_OMAP3_SPI(s) ? 0x3777f : 0x1777f;
488
 
                omap_mcspi_interrupt_update(s);
489
 
            }
490
 
        s->control = value & 0xf;
491
 
        break;
492
 
 
493
 
    case 0x68: ch ++;
494
 
        /* fall through */
495
 
    case 0x54: ch ++;
496
 
        /* fall through */
497
 
    case 0x40: ch ++;
498
 
        /* fall through */
499
 
    case 0x2c:  /* MCSPI_CHCONF */
500
 
        TRACE("CHCONF%d = 0x%08x", ch, value);
501
 
        if (ch < s->chnum) {
502
 
            old = s->ch[ch].config;
503
 
            s->ch[ch].config = value & (IS_OMAP3_SPI(s)
504
 
                                        ? 0x3fffffff : 0x7fffff);
505
 
            if (IS_OMAP3_SPI(s) &&
506
 
                ((value ^ old) & (3 << 27))) { /* FFER | FFEW */
507
 
                s->fifo_ch = ((value & (3 << 27))) ? ch : -1;
508
 
                omap_mcspi_fifo_reset(s);
509
 
            }
510
 
            if (((value ^ old) & (3 << 14)) || /* DMAR | DMAW */
511
 
                (IS_OMAP3_SPI(s) &&
512
 
                 ((value ^ old) & (3 << 27)))) /* FFER | FFEW */
513
 
                omap_mcspi_dmarequest_update(s, ch);
514
 
            if (((value >> 12) & 3) == 3) {   /* TRM */
515
 
                TRACE("invalid TRM value (3)");
516
 
            }
517
 
                if (((value >> 7) & 0x1f) < 3) {  /* WL */
518
 
                TRACE("invalid WL value (%" PRIx64 ")", (value >> 7) & 0x1f);
519
 
                }
520
 
            if (IS_OMAP3_SPI(s) && ((value >> 23) & 1)) { /* SBE */
521
 
                TRACE("start-bit mode is not supported");
522
 
            }
523
 
        }
524
 
        break;
525
 
 
526
 
    case 0x70: ch ++;
527
 
        /* fall through */
528
 
    case 0x5c: ch ++;
529
 
        /* fall through */
530
 
    case 0x48: ch ++;
531
 
        /* fall through */
532
 
    case 0x34:  /* MCSPI_CHCTRL */
533
 
        TRACE("CHCTRL%d = 0x%08x", ch, value);
534
 
        if (ch < s->chnum) {
535
 
            old = s->ch[ch].control;
536
 
            s->ch[ch].control = value & (IS_OMAP3_SPI(s) ? 0xff01 : 1);
537
 
            if (value & ~old & 1) { /* EN */
538
 
                if (IS_OMAP3_SPI(s) && s->fifo_ch == ch)
539
 
                    omap_mcspi_fifo_reset(s);
540
 
                omap_mcspi_transfer_run(s, ch);
541
 
            }
542
 
        }
543
 
        break;
544
 
 
545
 
    case 0x74: ch ++;
546
 
        /* fall through */
547
 
    case 0x60: ch ++;
548
 
        /* fall through */
549
 
    case 0x4c: ch ++;
550
 
        /* fall through */
551
 
    case 0x38:  /* MCSPI_TX */
552
 
        TRACE("TX%d = 0x%08x", ch, value);
553
 
        if (ch < s->chnum) {
554
 
            if (!IS_OMAP3_SPI(s) || s->fifo_ch != ch ||
555
 
                !(s->ch[ch].config & (1 << 27))) { /* FFEW */
556
 
                s->ch[ch].tx = value;
557
 
                s->ch[ch].status &= ~0x06;         /* EOT | TXS */
558
 
                omap_mcspi_transfer_run(s, ch);
559
 
            } else {
560
 
                if (s->tx_fifo.len >= s->tx_fifo.size) {
561
 
                    TRACE("txfifo overflow!");
562
 
                } else {
563
 
                    qemu_irq_lower(s->ch[ch].txdrq);
564
 
                    s->ch[ch].status &= ~0x0e;      /* TXFFE | EOT | TXS */
565
 
                    if (((s->ch[ch].config >> 12) & 3) != 1) {    /* TRM */
566
 
                        omap_mcspi_fifo_put(
567
 
                            &s->tx_fifo,
568
 
                            1 + ((s->ch[ch].config >> 7) & 0x1f), /* WL */
569
 
                            value);
570
 
                        if (s->tx_fifo.len >= s->tx_fifo.size)
571
 
                            s->ch[ch].status |= 1 << 4;        /* TXFFF */
572
 
                        if (s->tx_fifo.len >= (s->xferlevel & 0x3f))
573
 
                            omap_mcspi_transfer_run(s, ch);
574
 
                    } else {
575
 
                        s->ch[ch].tx = value;
576
 
                        omap_mcspi_transfer_run(s, ch);
577
 
                    }
578
 
                }
579
 
            }
580
 
        }
581
 
        break;
582
 
 
583
 
    case 0x7c: /* MCSPI_XFERLEVEL */
584
 
        TRACE("XFERLEVEL = 0x%08x", value);
585
 
        if (IS_OMAP3_SPI(s)) {
586
 
            if (value != s->xferlevel) {
587
 
                s->fifo_wcnt = (value >> 16) & 0xffff;
588
 
                s->xferlevel = value & 0xffff3f3f;
589
 
                omap_mcspi_fifo_reset(s);
590
 
            }
591
 
        } else
592
 
            OMAP_BAD_REG(addr);
593
 
        break;
594
 
 
595
 
    default:
596
 
        OMAP_BAD_REG(addr);
597
 
        return;
598
 
    }
599
 
}
600
 
 
601
 
static const MemoryRegionOps omap_mcspi_ops = {
602
 
    .read = omap_mcspi_read,
603
 
    .write = omap_mcspi_write,
604
 
    .endianness = DEVICE_NATIVE_ENDIAN,
605
 
};
606
 
 
607
 
static void omap_mcspi_reset(DeviceState *qdev)
608
 
{
609
 
    int i;
610
 
    OMAPSPIState *s = FROM_SYSBUS(OMAPSPIState, SYS_BUS_DEVICE(qdev));
611
 
    for (i = 0; i < s->buscount; i++) {
612
 
        omap_mcspi_bus_reset(&s->bus[i]);
613
 
    }
614
 
}
615
 
 
616
 
static int omap_mcspi_init(SysBusDevice *busdev)
617
 
{
618
 
    int i, j;
619
 
    OMAPSPIBusState *bs;
620
 
    OMAPSPIState *s = FROM_SYSBUS(OMAPSPIState, busdev);
621
 
    
622
 
    s->buscount = (s->mpu_model < omap3430) ? 2 : 4;
623
 
    s->bus = g_new0(OMAPSPIBusState, s->buscount);
624
 
    for (i = 0; i < s->buscount; i++) {
625
 
        bs = &s->bus[i];
626
 
        if (s->mpu_model < omap3430) {
627
 
            bs->revision = SPI_REV_OMAP2420;
628
 
            bs->chnum = i ? 2 : 4;
629
 
        } else {
630
 
            bs->revision = SPI_REV_OMAP3430;
631
 
            bs->chnum = (i > 2) ? 1 : (i ? 2 : 4);
632
 
        }
633
 
        sysbus_init_irq(busdev, &bs->irq);
634
 
        bs->bus = spi_init_bus(&busdev->qdev, NULL, bs->chnum);
635
 
        bs->ch = g_new0(struct omap_mcspi_ch_s, bs->chnum);
636
 
        for (j = 0; j < bs->chnum; j++) {
637
 
            sysbus_init_irq(busdev, &bs->ch[j].txdrq);
638
 
            sysbus_init_irq(busdev, &bs->ch[j].rxdrq);
639
 
        }
640
 
        memory_region_init_io(&bs->iomem, &omap_mcspi_ops, bs, "omap.mcspi",
641
 
                              0x1000);
642
 
        sysbus_init_mmio(busdev, &bs->iomem);
643
 
    }
644
 
    return 0;
645
 
}
646
 
 
647
 
SPIBus *omap_mcspi_bus(DeviceState *qdev, int bus_number)
648
 
{
649
 
    OMAPSPIState *s = FROM_SYSBUS(OMAPSPIState, SYS_BUS_DEVICE(qdev));
650
 
    if (bus_number < s->buscount) {
651
 
        return s->bus[bus_number].bus;
652
 
    }
653
 
    hw_error("%s: invalid bus number %d\n", __FUNCTION__, bus_number);
654
 
}
655
 
 
656
 
static Property omap_mcspi_properties[] = {
657
 
    DEFINE_PROP_INT32("mpu_model", OMAPSPIState, mpu_model, 0),
658
 
    DEFINE_PROP_END_OF_LIST()
659
 
};
660
 
 
661
 
static void omap_mcspi_class_init(ObjectClass *klass, void *data)
662
 
{
663
 
    DeviceClass *dc = DEVICE_CLASS(klass);
664
 
    SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
665
 
    k->init = omap_mcspi_init;
666
 
    dc->props = omap_mcspi_properties;
667
 
    dc->reset = omap_mcspi_reset;
668
 
}
669
 
 
670
 
static TypeInfo omap_mcspi_info = {
671
 
    .name = "omap_mcspi",
672
 
    .parent = TYPE_SYS_BUS_DEVICE,
673
 
    .instance_size = sizeof(OMAPSPIState),
674
 
    .class_init = omap_mcspi_class_init,
675
 
};
676
 
 
677
 
static void omap_mcspi_register_types(void)
678
 
{
679
 
    type_register_static(&omap_mcspi_info);
680
 
}
681
 
 
682
 
type_init(omap_mcspi_register_types)