← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/linaro/0065-musb-add-dummy-support-for-ulpi-pass-through-registe.patch/hw/usb/hcd-musb.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/linaro/0065-musb-add-dummy-support-for-ulpi-pass-through-registe.patch/hw/usb/hcd-musb.c
1
 
/*
2
 
 * "Inventra" High-speed Dual-Role Controller (MUSB-HDRC), Mentor Graphics,
3
 
 * USB2.0 OTG compliant core used in various chips.
4
 
 *
5
 
 * Copyright (C) 2008 Nokia Corporation
6
 
 * Written 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) version 3 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, see <http://www.gnu.org/licenses/>.
20
 
 *
21
 
 * Only host-mode and non-DMA accesses are currently supported.
22
 
 */
23
 
#include "qemu-common.h"
24
 
#include "qemu/timer.h"
25
 
#include "hw/usb.h"
26
 
#include "hw/irq.h"
27
 
#include "hw/hw.h"
28
 
 
29
 
/* Common USB registers */
30
 
#define MUSB_HDRC_FADDR         0x00    /* 8-bit */
31
 
#define MUSB_HDRC_POWER         0x01    /* 8-bit */
32
 
 
33
 
#define MUSB_HDRC_INTRTX        0x02    /* 16-bit */
34
 
#define MUSB_HDRC_INTRRX        0x04
35
 
#define MUSB_HDRC_INTRTXE       0x06  
36
 
#define MUSB_HDRC_INTRRXE       0x08  
37
 
#define MUSB_HDRC_INTRUSB       0x0a    /* 8 bit */
38
 
#define MUSB_HDRC_INTRUSBE      0x0b    /* 8 bit */
39
 
#define MUSB_HDRC_FRAME         0x0c    /* 16-bit */
40
 
#define MUSB_HDRC_INDEX         0x0e    /* 8 bit */
41
 
#define MUSB_HDRC_TESTMODE      0x0f    /* 8 bit */
42
 
 
43
 
/* Per-EP registers in indexed mode */
44
 
#define MUSB_HDRC_EP_IDX        0x10    /* 8-bit */
45
 
 
46
 
/* EP FIFOs */
47
 
#define MUSB_HDRC_FIFO          0x20
48
 
 
49
 
/* Additional Control Registers */
50
 
#define MUSB_HDRC_DEVCTL        0x60    /* 8 bit */
51
 
 
52
 
/* These are indexed */
53
 
#define MUSB_HDRC_TXFIFOSZ      0x62    /* 8 bit (see masks) */
54
 
#define MUSB_HDRC_RXFIFOSZ      0x63    /* 8 bit (see masks) */
55
 
#define MUSB_HDRC_TXFIFOADDR    0x64    /* 16 bit offset shifted right 3 */
56
 
#define MUSB_HDRC_RXFIFOADDR    0x66    /* 16 bit offset shifted right 3 */
57
 
 
58
 
/* Some more registers */
59
 
#define MUSB_HDRC_VCTRL         0x68    /* 8 bit */
60
 
#define MUSB_HDRC_HWVERS        0x6c    /* 8 bit */
61
 
 
62
 
/* Added in HDRC 1.9(?) & MHDRC 1.4 */
63
 
/* ULPI pass-through */
64
 
#define MUSB_HDRC_ULPI_VBUSCTL  0x70
65
 
#define MUSB_HDRC_ULPI_REGDATA  0x74
66
 
#define MUSB_HDRC_ULPI_REGADDR  0x75
67
 
#define MUSB_HDRC_ULPI_REGCTL   0x76
68
 
 
69
 
/* Extended config & PHY control */
70
 
#define MUSB_HDRC_ENDCOUNT      0x78    /* 8 bit */
71
 
#define MUSB_HDRC_DMARAMCFG     0x79    /* 8 bit */
72
 
#define MUSB_HDRC_PHYWAIT       0x7a    /* 8 bit */
73
 
#define MUSB_HDRC_PHYVPLEN      0x7b    /* 8 bit */
74
 
#define MUSB_HDRC_HS_EOF1       0x7c    /* 8 bit, units of 546.1 us */
75
 
#define MUSB_HDRC_FS_EOF1       0x7d    /* 8 bit, units of 533.3 ns */
76
 
#define MUSB_HDRC_LS_EOF1       0x7e    /* 8 bit, units of 1.067 us */
77
 
 
78
 
/* Per-EP BUSCTL registers */
79
 
#define MUSB_HDRC_BUSCTL        0x80
80
 
 
81
 
/* Per-EP registers in flat mode */
82
 
#define MUSB_HDRC_EP            0x100
83
 
 
84
 
/* offsets to registers in flat model */
85
 
#define MUSB_HDRC_TXMAXP        0x00    /* 16 bit apparently */
86
 
#define MUSB_HDRC_TXCSR         0x02    /* 16 bit apparently */
87
 
#define MUSB_HDRC_CSR0          MUSB_HDRC_TXCSR         /* re-used for EP0 */
88
 
#define MUSB_HDRC_RXMAXP        0x04    /* 16 bit apparently */
89
 
#define MUSB_HDRC_RXCSR         0x06    /* 16 bit apparently */
90
 
#define MUSB_HDRC_RXCOUNT       0x08    /* 16 bit apparently */
91
 
#define MUSB_HDRC_COUNT0        MUSB_HDRC_RXCOUNT       /* re-used for EP0 */
92
 
#define MUSB_HDRC_TXTYPE        0x0a    /* 8 bit apparently */
93
 
#define MUSB_HDRC_TYPE0         MUSB_HDRC_TXTYPE        /* re-used for EP0 */
94
 
#define MUSB_HDRC_TXINTERVAL    0x0b    /* 8 bit apparently */
95
 
#define MUSB_HDRC_NAKLIMIT0     MUSB_HDRC_TXINTERVAL    /* re-used for EP0 */
96
 
#define MUSB_HDRC_RXTYPE        0x0c    /* 8 bit apparently */
97
 
#define MUSB_HDRC_RXINTERVAL    0x0d    /* 8 bit apparently */
98
 
#define MUSB_HDRC_FIFOSIZE      0x0f    /* 8 bit apparently */
99
 
#define MUSB_HDRC_CONFIGDATA    MGC_O_HDRC_FIFOSIZE     /* re-used for EP0 */
100
 
 
101
 
/* "Bus control" registers */
102
 
#define MUSB_HDRC_TXFUNCADDR    0x00
103
 
#define MUSB_HDRC_TXHUBADDR     0x02
104
 
#define MUSB_HDRC_TXHUBPORT     0x03
105
 
 
106
 
#define MUSB_HDRC_RXFUNCADDR    0x04
107
 
#define MUSB_HDRC_RXHUBADDR     0x06
108
 
#define MUSB_HDRC_RXHUBPORT     0x07
109
 
 
110
 
/*
111
 
 * MUSBHDRC Register bit masks
112
 
 */
113
 
 
114
 
/* POWER */
115
 
#define MGC_M_POWER_ISOUPDATE           0x80 
116
 
#define MGC_M_POWER_SOFTCONN            0x40
117
 
#define MGC_M_POWER_HSENAB              0x20
118
 
#define MGC_M_POWER_HSMODE              0x10
119
 
#define MGC_M_POWER_RESET               0x08
120
 
#define MGC_M_POWER_RESUME              0x04
121
 
#define MGC_M_POWER_SUSPENDM            0x02
122
 
#define MGC_M_POWER_ENSUSPEND           0x01
123
 
 
124
 
/* INTRUSB */
125
 
#define MGC_M_INTR_SUSPEND              0x01
126
 
#define MGC_M_INTR_RESUME               0x02
127
 
#define MGC_M_INTR_RESET                0x04
128
 
#define MGC_M_INTR_BABBLE               0x04
129
 
#define MGC_M_INTR_SOF                  0x08 
130
 
#define MGC_M_INTR_CONNECT              0x10
131
 
#define MGC_M_INTR_DISCONNECT           0x20
132
 
#define MGC_M_INTR_SESSREQ              0x40
133
 
#define MGC_M_INTR_VBUSERROR            0x80    /* FOR SESSION END */
134
 
#define MGC_M_INTR_EP0                  0x01    /* FOR EP0 INTERRUPT */
135
 
 
136
 
/* DEVCTL */
137
 
#define MGC_M_DEVCTL_BDEVICE            0x80   
138
 
#define MGC_M_DEVCTL_FSDEV              0x40
139
 
#define MGC_M_DEVCTL_LSDEV              0x20
140
 
#define MGC_M_DEVCTL_VBUS               0x18
141
 
#define MGC_S_DEVCTL_VBUS               3
142
 
#define MGC_M_DEVCTL_HM                 0x04
143
 
#define MGC_M_DEVCTL_HR                 0x02
144
 
#define MGC_M_DEVCTL_SESSION            0x01
145
 
 
146
 
/* TESTMODE */
147
 
#define MGC_M_TEST_FORCE_HOST           0x80
148
 
#define MGC_M_TEST_FIFO_ACCESS          0x40
149
 
#define MGC_M_TEST_FORCE_FS             0x20
150
 
#define MGC_M_TEST_FORCE_HS             0x10
151
 
#define MGC_M_TEST_PACKET               0x08
152
 
#define MGC_M_TEST_K                    0x04
153
 
#define MGC_M_TEST_J                    0x02
154
 
#define MGC_M_TEST_SE0_NAK              0x01
155
 
 
156
 
/* CSR0 */
157
 
#define MGC_M_CSR0_FLUSHFIFO            0x0100
158
 
#define MGC_M_CSR0_TXPKTRDY             0x0002
159
 
#define MGC_M_CSR0_RXPKTRDY             0x0001
160
 
 
161
 
/* CSR0 in Peripheral mode */
162
 
#define MGC_M_CSR0_P_SVDSETUPEND        0x0080
163
 
#define MGC_M_CSR0_P_SVDRXPKTRDY        0x0040
164
 
#define MGC_M_CSR0_P_SENDSTALL          0x0020
165
 
#define MGC_M_CSR0_P_SETUPEND           0x0010
166
 
#define MGC_M_CSR0_P_DATAEND            0x0008
167
 
#define MGC_M_CSR0_P_SENTSTALL          0x0004
168
 
 
169
 
/* CSR0 in Host mode */
170
 
#define MGC_M_CSR0_H_NO_PING            0x0800
171
 
#define MGC_M_CSR0_H_WR_DATATOGGLE      0x0400  /* set to allow setting: */
172
 
#define MGC_M_CSR0_H_DATATOGGLE         0x0200  /* data toggle control */
173
 
#define MGC_M_CSR0_H_NAKTIMEOUT         0x0080
174
 
#define MGC_M_CSR0_H_STATUSPKT          0x0040
175
 
#define MGC_M_CSR0_H_REQPKT             0x0020
176
 
#define MGC_M_CSR0_H_ERROR              0x0010
177
 
#define MGC_M_CSR0_H_SETUPPKT           0x0008
178
 
#define MGC_M_CSR0_H_RXSTALL            0x0004
179
 
 
180
 
/* CONFIGDATA */
181
 
#define MGC_M_CONFIGDATA_MPRXE          0x80    /* auto bulk pkt combining */
182
 
#define MGC_M_CONFIGDATA_MPTXE          0x40    /* auto bulk pkt splitting */
183
 
#define MGC_M_CONFIGDATA_BIGENDIAN      0x20
184
 
#define MGC_M_CONFIGDATA_HBRXE          0x10    /* HB-ISO for RX */
185
 
#define MGC_M_CONFIGDATA_HBTXE          0x08    /* HB-ISO for TX */
186
 
#define MGC_M_CONFIGDATA_DYNFIFO        0x04    /* dynamic FIFO sizing */
187
 
#define MGC_M_CONFIGDATA_SOFTCONE       0x02    /* SoftConnect */
188
 
#define MGC_M_CONFIGDATA_UTMIDW         0x01    /* Width, 0 => 8b, 1 => 16b */
189
 
 
190
 
/* TXCSR in Peripheral and Host mode */
191
 
#define MGC_M_TXCSR_AUTOSET             0x8000
192
 
#define MGC_M_TXCSR_ISO                 0x4000
193
 
#define MGC_M_TXCSR_MODE                0x2000
194
 
#define MGC_M_TXCSR_DMAENAB             0x1000
195
 
#define MGC_M_TXCSR_FRCDATATOG          0x0800
196
 
#define MGC_M_TXCSR_DMAMODE             0x0400
197
 
#define MGC_M_TXCSR_CLRDATATOG          0x0040
198
 
#define MGC_M_TXCSR_FLUSHFIFO           0x0008
199
 
#define MGC_M_TXCSR_FIFONOTEMPTY        0x0002
200
 
#define MGC_M_TXCSR_TXPKTRDY            0x0001
201
 
 
202
 
/* TXCSR in Peripheral mode */
203
 
#define MGC_M_TXCSR_P_INCOMPTX          0x0080
204
 
#define MGC_M_TXCSR_P_SENTSTALL         0x0020
205
 
#define MGC_M_TXCSR_P_SENDSTALL         0x0010
206
 
#define MGC_M_TXCSR_P_UNDERRUN          0x0004
207
 
 
208
 
/* TXCSR in Host mode */
209
 
#define MGC_M_TXCSR_H_WR_DATATOGGLE     0x0200
210
 
#define MGC_M_TXCSR_H_DATATOGGLE        0x0100
211
 
#define MGC_M_TXCSR_H_NAKTIMEOUT        0x0080
212
 
#define MGC_M_TXCSR_H_RXSTALL           0x0020
213
 
#define MGC_M_TXCSR_H_ERROR             0x0004
214
 
 
215
 
/* RXCSR in Peripheral and Host mode */
216
 
#define MGC_M_RXCSR_AUTOCLEAR           0x8000
217
 
#define MGC_M_RXCSR_DMAENAB             0x2000
218
 
#define MGC_M_RXCSR_DISNYET             0x1000
219
 
#define MGC_M_RXCSR_DMAMODE             0x0800
220
 
#define MGC_M_RXCSR_INCOMPRX            0x0100
221
 
#define MGC_M_RXCSR_CLRDATATOG          0x0080
222
 
#define MGC_M_RXCSR_FLUSHFIFO           0x0010
223
 
#define MGC_M_RXCSR_DATAERROR           0x0008
224
 
#define MGC_M_RXCSR_FIFOFULL            0x0002
225
 
#define MGC_M_RXCSR_RXPKTRDY            0x0001
226
 
 
227
 
/* RXCSR in Peripheral mode */
228
 
#define MGC_M_RXCSR_P_ISO               0x4000
229
 
#define MGC_M_RXCSR_P_SENTSTALL         0x0040
230
 
#define MGC_M_RXCSR_P_SENDSTALL         0x0020
231
 
#define MGC_M_RXCSR_P_OVERRUN           0x0004
232
 
 
233
 
/* RXCSR in Host mode */
234
 
#define MGC_M_RXCSR_H_AUTOREQ           0x4000
235
 
#define MGC_M_RXCSR_H_WR_DATATOGGLE     0x0400
236
 
#define MGC_M_RXCSR_H_DATATOGGLE        0x0200
237
 
#define MGC_M_RXCSR_H_RXSTALL           0x0040
238
 
#define MGC_M_RXCSR_H_REQPKT            0x0020
239
 
#define MGC_M_RXCSR_H_ERROR             0x0004
240
 
 
241
 
/* HUBADDR */
242
 
#define MGC_M_HUBADDR_MULTI_TT          0x80
243
 
 
244
 
/* ULPI: Added in HDRC 1.9(?) & MHDRC 1.4 */
245
 
#define MGC_M_ULPI_VBCTL_USEEXTVBUSIND  0x02
246
 
#define MGC_M_ULPI_VBCTL_USEEXTVBUS     0x01
247
 
#define MGC_M_ULPI_REGCTL_INT_ENABLE    0x08
248
 
#define MGC_M_ULPI_REGCTL_READNOTWRITE  0x04
249
 
#define MGC_M_ULPI_REGCTL_COMPLETE      0x02
250
 
#define MGC_M_ULPI_REGCTL_REG           0x01
251
 
 
252
 
/* #define MUSB_DEBUG */
253
 
 
254
 
#ifdef MUSB_DEBUG
255
 
#define TRACE(fmt,...) fprintf(stderr, "%s@%d: " fmt "\n", __FUNCTION__, \
256
 
                               __LINE__, ##__VA_ARGS__)
257
 
#else
258
 
#define TRACE(...)
259
 
#endif
260
 
 
261
 
 
262
 
static void musb_attach(USBPort *port);
263
 
static void musb_detach(USBPort *port);
264
 
static void musb_child_detach(USBPort *port, USBDevice *child);
265
 
static void musb_schedule_cb(USBPort *port, USBPacket *p);
266
 
static void musb_async_cancel_device(MUSBState *s, USBDevice *dev);
267
 
 
268
 
static USBPortOps musb_port_ops = {
269
 
    .attach = musb_attach,
270
 
    .detach = musb_detach,
271
 
    .child_detach = musb_child_detach,
272
 
    .complete = musb_schedule_cb,
273
 
};
274
 
 
275
 
static USBBusOps musb_bus_ops = {
276
 
};
277
 
 
278
 
typedef struct MUSBPacket MUSBPacket;
279
 
typedef struct MUSBEndPoint MUSBEndPoint;
280
 
 
281
 
struct MUSBPacket {
282
 
    USBPacket p;
283
 
    MUSBEndPoint *ep;
284
 
    int dir;
285
 
};
286
 
 
287
 
struct MUSBEndPoint {
288
 
    uint16_t faddr[2];
289
 
    uint8_t haddr[2];
290
 
    uint8_t hport[2];
291
 
    uint16_t csr[2];
292
 
    uint16_t maxp[2];
293
 
    uint16_t rxcount;
294
 
    uint8_t type[2];
295
 
    uint8_t interval[2];
296
 
    uint8_t config;
297
 
    uint8_t fifosize;
298
 
    int timeout[2];     /* Always in microframes */
299
 
 
300
 
    uint8_t *buf[2];
301
 
    int fifolen[2];
302
 
    int fifostart[2];
303
 
    int fifoaddr[2];
304
 
    MUSBPacket packey[2];
305
 
    int status[2];
306
 
    int ext_size[2];
307
 
 
308
 
    /* For callbacks' use */
309
 
    int epnum;
310
 
    int interrupt[2];
311
 
    MUSBState *musb;
312
 
    USBCallback *delayed_cb[2];
313
 
    QEMUTimer *intv_timer[2];
314
 
};
315
 
 
316
 
struct MUSBState {
317
 
    qemu_irq irqs[musb_irq_max];
318
 
    USBBus bus;
319
 
    USBPort port;
320
 
 
321
 
    int idx;
322
 
    uint8_t devctl;
323
 
    uint8_t power;
324
 
    uint8_t faddr;
325
 
 
326
 
    uint8_t intr;
327
 
    uint8_t mask;
328
 
    uint16_t tx_intr;
329
 
    uint16_t tx_mask;
330
 
    uint16_t rx_intr;
331
 
    uint16_t rx_mask;
332
 
 
333
 
    int setup_len;
334
 
    int session;
335
 
 
336
 
    uint8_t buf[0x8000];
337
 
 
338
 
        /* Duplicating the world since 2008!...  probably we should have 32
339
 
         * logical, single endpoints instead.  */
340
 
    MUSBEndPoint ep[16];
341
 
};
342
 
 
343
 
void musb_reset(MUSBState *s)
344
 
{
345
 
    int i;
346
 
 
347
 
    s->faddr = 0x00;
348
 
    s->devctl = 0;
349
 
    s->power = MGC_M_POWER_HSENAB;
350
 
    s->tx_intr = 0x0000;
351
 
    s->rx_intr = 0x0000;
352
 
    s->tx_mask = 0xffff;
353
 
    s->rx_mask = 0xffff;
354
 
    s->intr = 0x00;
355
 
    s->mask = 0x06;
356
 
    s->idx = 0;
357
 
 
358
 
    s->setup_len = 0;
359
 
    s->session = 0;
360
 
    memset(s->buf, 0, sizeof(s->buf));
361
 
 
362
 
    /* TODO: _DW */
363
 
    s->ep[0].config = MGC_M_CONFIGDATA_SOFTCONE | MGC_M_CONFIGDATA_DYNFIFO;
364
 
    for (i = 0; i < 16; i ++) {
365
 
        s->ep[i].fifosize = 64;
366
 
        s->ep[i].maxp[0] = 0x40;
367
 
        s->ep[i].maxp[1] = 0x40;
368
 
        s->ep[i].musb = s;
369
 
        s->ep[i].epnum = i;
370
 
        usb_packet_init(&s->ep[i].packey[0].p);
371
 
        usb_packet_init(&s->ep[i].packey[1].p);
372
 
    }
373
 
}
374
 
 
375
 
struct MUSBState *musb_init(DeviceState *parent_device, int gpio_base)
376
 
{
377
 
    MUSBState *s = g_malloc0(sizeof(*s));
378
 
    int i;
379
 
 
380
 
    for (i = 0; i < musb_irq_max; i++) {
381
 
        s->irqs[i] = qdev_get_gpio_in(parent_device, gpio_base + i);
382
 
    }
383
 
 
384
 
    musb_reset(s);
385
 
 
386
 
    usb_bus_new(&s->bus, sizeof(s->bus), &musb_bus_ops, parent_device);
387
 
    usb_register_port(&s->bus, &s->port, s, 0, &musb_port_ops,
388
 
                      USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
389
 
 
390
 
    return s;
391
 
}
392
 
 
393
 
static void musb_vbus_set(MUSBState *s, int level)
394
 
{
395
 
    if (level)
396
 
        s->devctl |= 3 << MGC_S_DEVCTL_VBUS;
397
 
    else
398
 
        s->devctl &= ~MGC_M_DEVCTL_VBUS;
399
 
 
400
 
    qemu_set_irq(s->irqs[musb_set_vbus], level);
401
 
}
402
 
 
403
 
static void musb_intr_set(MUSBState *s, int line, int level)
404
 
{
405
 
    if (!level) {
406
 
        s->intr &= ~(1 << line);
407
 
        qemu_irq_lower(s->irqs[line]);
408
 
    } else if (s->mask & (1 << line)) {
409
 
        s->intr |= 1 << line;
410
 
        qemu_irq_raise(s->irqs[line]);
411
 
    }
412
 
}
413
 
 
414
 
static void musb_tx_intr_set(MUSBState *s, int line, int level)
415
 
{
416
 
    if (!level) {
417
 
        s->tx_intr &= ~(1 << line);
418
 
        if (!s->tx_intr)
419
 
            qemu_irq_lower(s->irqs[musb_irq_tx]);
420
 
    } else if (s->tx_mask & (1 << line)) {
421
 
        s->tx_intr |= 1 << line;
422
 
        qemu_irq_raise(s->irqs[musb_irq_tx]);
423
 
    }
424
 
}
425
 
 
426
 
static void musb_rx_intr_set(MUSBState *s, int line, int level)
427
 
{
428
 
    if (line) {
429
 
        if (!level) {
430
 
            s->rx_intr &= ~(1 << line);
431
 
            if (!s->rx_intr)
432
 
                qemu_irq_lower(s->irqs[musb_irq_rx]);
433
 
        } else if (s->rx_mask & (1 << line)) {
434
 
            s->rx_intr |= 1 << line;
435
 
            qemu_irq_raise(s->irqs[musb_irq_rx]);
436
 
        }
437
 
    } else
438
 
        musb_tx_intr_set(s, line, level);
439
 
}
440
 
 
441
 
uint32_t musb_core_intr_get(MUSBState *s)
442
 
{
443
 
    return (s->rx_intr << 15) | s->tx_intr;
444
 
}
445
 
 
446
 
void musb_core_intr_clear(MUSBState *s, uint32_t mask)
447
 
{
448
 
    if (s->rx_intr) {
449
 
        s->rx_intr &= mask >> 15;
450
 
        if (!s->rx_intr)
451
 
            qemu_irq_lower(s->irqs[musb_irq_rx]);
452
 
    }
453
 
 
454
 
    if (s->tx_intr) {
455
 
        s->tx_intr &= mask & 0xffff;
456
 
        if (!s->tx_intr)
457
 
            qemu_irq_lower(s->irqs[musb_irq_tx]);
458
 
    }
459
 
}
460
 
 
461
 
void musb_set_size(MUSBState *s, int epnum, int size, int is_tx)
462
 
{
463
 
    s->ep[epnum].ext_size[!is_tx] = size;
464
 
    s->ep[epnum].fifostart[0] = 0;
465
 
    s->ep[epnum].fifostart[1] = 0;
466
 
    s->ep[epnum].fifolen[0] = 0;
467
 
    s->ep[epnum].fifolen[1] = 0;
468
 
}
469
 
 
470
 
static void musb_session_update(MUSBState *s, int prev_dev, int prev_sess)
471
 
{
472
 
    int detect_prev = prev_dev && prev_sess;
473
 
    int detect = !!s->port.dev && s->session;
474
 
 
475
 
    if (detect && !detect_prev) {
476
 
        /* Let's skip the ID pin sense and VBUS sense formalities and
477
 
         * and signal a successful SRP directly.  This should work at least
478
 
         * for the Linux driver stack.  */
479
 
        musb_intr_set(s, musb_irq_connect, 1);
480
 
 
481
 
        if (s->port.dev->speed == USB_SPEED_LOW) {
482
 
            s->devctl &= ~MGC_M_DEVCTL_FSDEV;
483
 
            s->devctl |= MGC_M_DEVCTL_LSDEV;
484
 
        } else {
485
 
            s->devctl |= MGC_M_DEVCTL_FSDEV;
486
 
            s->devctl &= ~MGC_M_DEVCTL_LSDEV;
487
 
        }
488
 
 
489
 
        /* A-mode?  */
490
 
        s->devctl &= ~MGC_M_DEVCTL_BDEVICE;
491
 
 
492
 
        /* Host-mode bit?  */
493
 
        s->devctl |= MGC_M_DEVCTL_HM;
494
 
#if 1
495
 
        musb_vbus_set(s, 1);
496
 
#endif
497
 
    } else if (!detect && detect_prev) {
498
 
#if 1
499
 
        musb_vbus_set(s, 0);
500
 
#endif
501
 
    }
502
 
}
503
 
 
504
 
/* Attach or detach a device on our only port.  */
505
 
static void musb_attach(USBPort *port)
506
 
{
507
 
    MUSBState *s = (MUSBState *) port->opaque;
508
 
 
509
 
    musb_intr_set(s, musb_irq_vbus_request, 1);
510
 
    musb_session_update(s, 0, s->session);
511
 
}
512
 
 
513
 
static void musb_detach(USBPort *port)
514
 
{
515
 
    MUSBState *s = (MUSBState *) port->opaque;
516
 
 
517
 
    musb_async_cancel_device(s, port->dev);
518
 
 
519
 
    musb_intr_set(s, musb_irq_disconnect, 1);
520
 
    musb_session_update(s, 1, s->session);
521
 
}
522
 
 
523
 
static void musb_child_detach(USBPort *port, USBDevice *child)
524
 
{
525
 
    MUSBState *s = (MUSBState *) port->opaque;
526
 
 
527
 
    musb_async_cancel_device(s, child);
528
 
}
529
 
 
530
 
static void musb_cb_tick0(void *opaque)
531
 
{
532
 
    MUSBEndPoint *ep = (MUSBEndPoint *) opaque;
533
 
 
534
 
    ep->delayed_cb[0](&ep->packey[0].p, opaque);
535
 
}
536
 
 
537
 
static void musb_cb_tick1(void *opaque)
538
 
{
539
 
    MUSBEndPoint *ep = (MUSBEndPoint *) opaque;
540
 
 
541
 
    ep->delayed_cb[1](&ep->packey[1].p, opaque);
542
 
}
543
 
 
544
 
#define musb_cb_tick    (dir ? musb_cb_tick1 : musb_cb_tick0)
545
 
 
546
 
static void musb_schedule_cb(USBPort *port, USBPacket *packey)
547
 
{
548
 
    MUSBPacket *p = container_of(packey, MUSBPacket, p);
549
 
    MUSBEndPoint *ep = p->ep;
550
 
    int dir = p->dir;
551
 
    int timeout = 0;
552
 
 
553
 
    if (ep->status[dir] == USB_RET_NAK)
554
 
        timeout = ep->timeout[dir];
555
 
    else if (ep->interrupt[dir])
556
 
        timeout = 8;
557
 
    else
558
 
        return musb_cb_tick(ep);
559
 
 
560
 
    if (!ep->intv_timer[dir])
561
 
        ep->intv_timer[dir] = timer_new_ns(QEMU_CLOCK_VIRTUAL, musb_cb_tick, ep);
562
 
 
563
 
    timer_mod(ep->intv_timer[dir], qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
564
 
                   muldiv64(timeout, get_ticks_per_sec(), 8000));
565
 
}
566
 
 
567
 
static int musb_timeout(int ttype, int speed, int val)
568
 
{
569
 
#if 1
570
 
    return val << 3;
571
 
#endif
572
 
 
573
 
    switch (ttype) {
574
 
    case USB_ENDPOINT_XFER_CONTROL:
575
 
        if (val < 2)
576
 
            return 0;
577
 
        else if (speed == USB_SPEED_HIGH)
578
 
            return 1 << (val - 1);
579
 
        else
580
 
            return 8 << (val - 1);
581
 
 
582
 
    case USB_ENDPOINT_XFER_INT:
583
 
        if (speed == USB_SPEED_HIGH)
584
 
            if (val < 2)
585
 
                return 0;
586
 
            else
587
 
                return 1 << (val - 1);
588
 
        else
589
 
            return val << 3;
590
 
 
591
 
    case USB_ENDPOINT_XFER_BULK:
592
 
    case USB_ENDPOINT_XFER_ISOC:
593
 
        if (val < 2)
594
 
            return 0;
595
 
        else if (speed == USB_SPEED_HIGH)
596
 
            return 1 << (val - 1);
597
 
        else
598
 
            return 8 << (val - 1);
599
 
        /* TODO: what with low-speed Bulk and Isochronous?  */
600
 
    }
601
 
 
602
 
    hw_error("bad interval\n");
603
 
}
604
 
 
605
 
static void musb_packet(MUSBState *s, MUSBEndPoint *ep,
606
 
                int epnum, int pid, int len, USBCallback cb, int dir)
607
 
{
608
 
    USBDevice *dev;
609
 
    USBEndpoint *uep;
610
 
    int idx = epnum && dir;
611
 
    int ttype;
612
 
 
613
 
    /* ep->type[0,1] contains:
614
 
     * in bits 7:6 the speed (0 - invalid, 1 - high, 2 - full, 3 - slow)
615
 
     * in bits 5:4 the transfer type (BULK / INT)
616
 
     * in bits 3:0 the EP num
617
 
     */
618
 
    ttype = epnum ? (ep->type[idx] >> 4) & 3 : 0;
619
 
 
620
 
    ep->timeout[dir] = musb_timeout(ttype,
621
 
                    ep->type[idx] >> 6, ep->interval[idx]);
622
 
    ep->interrupt[dir] = ttype == USB_ENDPOINT_XFER_INT;
623
 
    ep->delayed_cb[dir] = cb;
624
 
 
625
 
    /* A wild guess on the FADDR semantics... */
626
 
    dev = usb_find_device(&s->port, ep->faddr[idx]);
627
 
    uep = usb_ep_get(dev, pid, ep->type[idx] & 0xf);
628
 
    usb_packet_setup(&ep->packey[dir].p, pid, uep, 0,
629
 
                     (dev->addr << 16) | (uep->nr << 8) | pid, false, true);
630
 
    usb_packet_addbuf(&ep->packey[dir].p, ep->buf[idx], len);
631
 
    ep->packey[dir].ep = ep;
632
 
    ep->packey[dir].dir = dir;
633
 
 
634
 
    usb_handle_packet(dev, &ep->packey[dir].p);
635
 
 
636
 
    if (ep->packey[dir].p.status == USB_RET_ASYNC) {
637
 
        usb_device_flush_ep_queue(dev, uep);
638
 
        ep->status[dir] = len;
639
 
        return;
640
 
    }
641
 
 
642
 
    if (ep->packey[dir].p.status == USB_RET_SUCCESS) {
643
 
        ep->status[dir] = ep->packey[dir].p.actual_length;
644
 
    } else {
645
 
        ep->status[dir] = ep->packey[dir].p.status;
646
 
    }
647
 
    musb_schedule_cb(&s->port, &ep->packey[dir].p);
648
 
}
649
 
 
650
 
static void musb_tx_packet_complete(USBPacket *packey, void *opaque)
651
 
{
652
 
    /* Unfortunately we can't use packey->devep because that's the remote
653
 
     * endpoint number and may be different than our local.  */
654
 
    MUSBEndPoint *ep = (MUSBEndPoint *) opaque;
655
 
    int epnum = ep->epnum;
656
 
    MUSBState *s = ep->musb;
657
 
 
658
 
    ep->fifostart[0] = 0;
659
 
    ep->fifolen[0] = 0;
660
 
#ifdef CLEAR_NAK
661
 
    if (ep->status[0] != USB_RET_NAK) {
662
 
#endif
663
 
        if (epnum)
664
 
            ep->csr[0] &= ~(MGC_M_TXCSR_FIFONOTEMPTY | MGC_M_TXCSR_TXPKTRDY);
665
 
        else
666
 
            ep->csr[0] &= ~MGC_M_CSR0_TXPKTRDY;
667
 
#ifdef CLEAR_NAK
668
 
    }
669
 
#endif
670
 
 
671
 
    /* Clear all of the error bits first */
672
 
    if (epnum)
673
 
        ep->csr[0] &= ~(MGC_M_TXCSR_H_ERROR | MGC_M_TXCSR_H_RXSTALL |
674
 
                        MGC_M_TXCSR_H_NAKTIMEOUT);
675
 
    else
676
 
        ep->csr[0] &= ~(MGC_M_CSR0_H_ERROR | MGC_M_CSR0_H_RXSTALL |
677
 
                        MGC_M_CSR0_H_NAKTIMEOUT | MGC_M_CSR0_H_NO_PING);
678
 
 
679
 
    if (ep->status[0] == USB_RET_STALL) {
680
 
        /* Command not supported by target! */
681
 
        ep->status[0] = 0;
682
 
 
683
 
        if (epnum)
684
 
            ep->csr[0] |= MGC_M_TXCSR_H_RXSTALL;
685
 
        else
686
 
            ep->csr[0] |= MGC_M_CSR0_H_RXSTALL;
687
 
    }
688
 
 
689
 
    if (ep->status[0] == USB_RET_NAK) {
690
 
        ep->status[0] = 0;
691
 
 
692
 
        /* NAK timeouts are only generated in Bulk transfers and
693
 
         * Data-errors in Isochronous.  */
694
 
        if (ep->interrupt[0]) {
695
 
            return;
696
 
        }
697
 
 
698
 
        if (epnum)
699
 
            ep->csr[0] |= MGC_M_TXCSR_H_NAKTIMEOUT;
700
 
        else
701
 
            ep->csr[0] |= MGC_M_CSR0_H_NAKTIMEOUT;
702
 
    }
703
 
 
704
 
    if (ep->status[0] < 0) {
705
 
        if (ep->status[0] == USB_RET_BABBLE)
706
 
            musb_intr_set(s, musb_irq_rst_babble, 1);
707
 
 
708
 
        /* Pretend we've tried three times already and failed (in
709
 
         * case of USB_TOKEN_SETUP).  */
710
 
        if (epnum)
711
 
            ep->csr[0] |= MGC_M_TXCSR_H_ERROR;
712
 
        else
713
 
            ep->csr[0] |= MGC_M_CSR0_H_ERROR;
714
 
 
715
 
        musb_tx_intr_set(s, epnum, 1);
716
 
        return;
717
 
    }
718
 
    /* TODO: check len for over/underruns of an OUT packet?  */
719
 
 
720
 
#ifdef SETUPLEN_HACK
721
 
    if (!epnum && ep->packey[0].pid == USB_TOKEN_SETUP)
722
 
        s->setup_len = ep->packey[0].data[6];
723
 
#endif
724
 
 
725
 
    /* In DMA mode: if no error, assert DMA request for this EP,
726
 
     * and skip the interrupt.  */
727
 
    musb_tx_intr_set(s, epnum, 1);
728
 
}
729
 
 
730
 
static void musb_rx_packet_complete(USBPacket *packey, void *opaque)
731
 
{
732
 
    /* Unfortunately we can't use packey->devep because that's the remote
733
 
     * endpoint number and may be different than our local.  */
734
 
    MUSBEndPoint *ep = (MUSBEndPoint *) opaque;
735
 
    int epnum = ep->epnum;
736
 
    MUSBState *s = ep->musb;
737
 
 
738
 
    ep->fifostart[1] = 0;
739
 
    ep->fifolen[1] = 0;
740
 
 
741
 
#ifdef CLEAR_NAK
742
 
    if (ep->status[1] != USB_RET_NAK) {
743
 
#endif
744
 
        ep->csr[1] &= ~MGC_M_RXCSR_H_REQPKT;
745
 
        if (!epnum)
746
 
            ep->csr[0] &= ~MGC_M_CSR0_H_REQPKT;
747
 
#ifdef CLEAR_NAK
748
 
    }
749
 
#endif
750
 
 
751
 
    /* Clear all of the imaginable error bits first */
752
 
    ep->csr[1] &= ~(MGC_M_RXCSR_H_ERROR | MGC_M_RXCSR_H_RXSTALL |
753
 
                    MGC_M_RXCSR_DATAERROR);
754
 
    if (!epnum)
755
 
        ep->csr[0] &= ~(MGC_M_CSR0_H_ERROR | MGC_M_CSR0_H_RXSTALL |
756
 
                        MGC_M_CSR0_H_NAKTIMEOUT | MGC_M_CSR0_H_NO_PING);
757
 
 
758
 
    if (ep->status[1] == USB_RET_STALL) {
759
 
        ep->status[1] = 0;
760
 
 
761
 
        ep->csr[1] |= MGC_M_RXCSR_H_RXSTALL;
762
 
        if (!epnum)
763
 
            ep->csr[0] |= MGC_M_CSR0_H_RXSTALL;
764
 
    }
765
 
 
766
 
    if (ep->status[1] == USB_RET_NAK) {
767
 
        ep->status[1] = 0;
768
 
 
769
 
        /* NAK timeouts are only generated in Bulk transfers and
770
 
         * Data-errors in Isochronous.  */
771
 
        if (ep->interrupt[1])
772
 
            return musb_packet(s, ep, epnum, USB_TOKEN_IN,
773
 
                            packey->iov.size, musb_rx_packet_complete, 1);
774
 
 
775
 
        ep->csr[1] |= MGC_M_RXCSR_DATAERROR;
776
 
        if (!epnum)
777
 
            ep->csr[0] |= MGC_M_CSR0_H_NAKTIMEOUT;
778
 
    }
779
 
 
780
 
    if (ep->status[1] < 0) {
781
 
        if (ep->status[1] == USB_RET_BABBLE) {
782
 
            musb_intr_set(s, musb_irq_rst_babble, 1);
783
 
            return;
784
 
        }
785
 
 
786
 
        /* Pretend we've tried three times already and failed (in
787
 
         * case of a control transfer).  */
788
 
        ep->csr[1] |= MGC_M_RXCSR_H_ERROR;
789
 
        if (!epnum)
790
 
            ep->csr[0] |= MGC_M_CSR0_H_ERROR;
791
 
 
792
 
        musb_rx_intr_set(s, epnum, 1);
793
 
        return;
794
 
    }
795
 
    /* TODO: check len for over/underruns of an OUT packet?  */
796
 
    /* TODO: perhaps make use of e->ext_size[1] here.  */
797
 
 
798
 
    if (!(ep->csr[1] & (MGC_M_RXCSR_H_RXSTALL | MGC_M_RXCSR_DATAERROR))) {
799
 
        ep->csr[1] |= MGC_M_RXCSR_FIFOFULL | MGC_M_RXCSR_RXPKTRDY;
800
 
        if (!epnum)
801
 
            ep->csr[0] |= MGC_M_CSR0_RXPKTRDY;
802
 
 
803
 
        ep->rxcount = ep->status[1]; /* XXX: MIN(packey->len, ep->maxp[1]); */
804
 
        /* In DMA mode: assert DMA request for this EP */
805
 
    }
806
 
 
807
 
    /* Only if DMA has not been asserted */
808
 
    musb_rx_intr_set(s, epnum, 1);
809
 
}
810
 
 
811
 
static void musb_async_cancel_device(MUSBState *s, USBDevice *dev)
812
 
{
813
 
    int ep, dir;
814
 
 
815
 
    for (ep = 0; ep < 16; ep++) {
816
 
        for (dir = 0; dir < 2; dir++) {
817
 
            if (!usb_packet_is_inflight(&s->ep[ep].packey[dir].p) ||
818
 
                s->ep[ep].packey[dir].p.ep->dev != dev) {
819
 
                continue;
820
 
            }
821
 
            usb_cancel_packet(&s->ep[ep].packey[dir].p);
822
 
            /* status updates needed here? */
823
 
        }
824
 
    }
825
 
}
826
 
 
827
 
static void musb_tx_rdy(MUSBState *s, int epnum)
828
 
{
829
 
    MUSBEndPoint *ep = s->ep + epnum;
830
 
    int pid;
831
 
    int total, valid = 0;
832
 
    TRACE("start %d, len %d",  ep->fifostart[0], ep->fifolen[0] );
833
 
    ep->fifostart[0] += ep->fifolen[0];
834
 
    ep->fifolen[0] = 0;
835
 
 
836
 
    /* XXX: how's the total size of the packet retrieved exactly in
837
 
     * the generic case?  */
838
 
    total = ep->maxp[0] & 0x3ff;
839
 
 
840
 
    if (ep->ext_size[0]) {
841
 
        total = ep->ext_size[0];
842
 
        ep->ext_size[0] = 0;
843
 
        valid = 1;
844
 
    }
845
 
 
846
 
    /* If the packet is not fully ready yet, wait for a next segment.  */
847
 
    if (epnum && (ep->fifostart[0]) < total)
848
 
        return;
849
 
 
850
 
    if (!valid)
851
 
        total = ep->fifostart[0];
852
 
 
853
 
    pid = USB_TOKEN_OUT;
854
 
    if (!epnum && (ep->csr[0] & MGC_M_CSR0_H_SETUPPKT)) {
855
 
        pid = USB_TOKEN_SETUP;
856
 
        if (total != 8) {
857
 
            TRACE("illegal SETUPPKT length of %i bytes", total);
858
 
        }
859
 
        /* Controller should retry SETUP packets three times on errors
860
 
         * but it doesn't make sense for us to do that.  */
861
 
    }
862
 
 
863
 
    return musb_packet(s, ep, epnum, pid,
864
 
                    total, musb_tx_packet_complete, 0);
865
 
}
866
 
 
867
 
static void musb_rx_req(MUSBState *s, int epnum)
868
 
{
869
 
    MUSBEndPoint *ep = s->ep + epnum;
870
 
    int total;
871
 
 
872
 
    /* If we already have a packet, which didn't fit into the
873
 
     * 64 bytes of the FIFO, only move the FIFO start and return. (Obsolete) */
874
 
    if (ep->packey[1].p.pid == USB_TOKEN_IN && ep->status[1] >= 0 &&
875
 
                    (ep->fifostart[1]) + ep->rxcount <
876
 
                    ep->packey[1].p.iov.size) {
877
 
        TRACE("0x%08x, %d",  ep->fifostart[1], ep->rxcount );
878
 
        ep->fifostart[1] += ep->rxcount;
879
 
        ep->fifolen[1] = 0;
880
 
 
881
 
        ep->rxcount = MIN(ep->packey[0].p.iov.size - (ep->fifostart[1]),
882
 
                        ep->maxp[1]);
883
 
 
884
 
        ep->csr[1] &= ~MGC_M_RXCSR_H_REQPKT;
885
 
        if (!epnum)
886
 
            ep->csr[0] &= ~MGC_M_CSR0_H_REQPKT;
887
 
 
888
 
        /* Clear all of the error bits first */
889
 
        ep->csr[1] &= ~(MGC_M_RXCSR_H_ERROR | MGC_M_RXCSR_H_RXSTALL |
890
 
                        MGC_M_RXCSR_DATAERROR);
891
 
        if (!epnum)
892
 
            ep->csr[0] &= ~(MGC_M_CSR0_H_ERROR | MGC_M_CSR0_H_RXSTALL |
893
 
                            MGC_M_CSR0_H_NAKTIMEOUT | MGC_M_CSR0_H_NO_PING);
894
 
 
895
 
        ep->csr[1] |= MGC_M_RXCSR_FIFOFULL | MGC_M_RXCSR_RXPKTRDY;
896
 
        if (!epnum)
897
 
            ep->csr[0] |= MGC_M_CSR0_RXPKTRDY;
898
 
        musb_rx_intr_set(s, epnum, 1);
899
 
        return;
900
 
    }
901
 
 
902
 
    /* The driver sets maxp[1] to 64 or less because it knows the hardware
903
 
     * FIFO is this deep.  Bigger packets get split in
904
 
     * usb_generic_handle_packet but we can also do the splitting locally
905
 
     * for performance.  It turns out we can also have a bigger FIFO and
906
 
     * ignore the limit set in ep->maxp[1].  The Linux MUSB driver deals
907
 
     * OK with single packets of even 32KB and we avoid splitting, however
908
 
     * usb_msd.c sometimes sends a packet bigger than what Linux expects
909
 
     * (e.g. 8192 bytes instead of 4096) and we get an OVERRUN.  Splitting
910
 
     * hides this overrun from Linux.  Up to 4096 everything is fine
911
 
     * though.  Currently this is disabled.
912
 
     *
913
 
     * XXX: mind ep->fifosize.  */
914
 
    total = MIN(ep->maxp[1] & 0x3ff, sizeof(s->buf));
915
 
 
916
 
#ifdef SETUPLEN_HACK
917
 
    /* Why should *we* do that instead of Linux?  */
918
 
    if (!epnum) {
919
 
        if (ep->packey[0].p.devaddr == 2) {
920
 
            total = MIN(s->setup_len, 8);
921
 
        } else {
922
 
            total = MIN(s->setup_len, 64);
923
 
        }
924
 
        s->setup_len -= total;
925
 
    }
926
 
#endif
927
 
 
928
 
    return musb_packet(s, ep, epnum, USB_TOKEN_IN,
929
 
                    total, musb_rx_packet_complete, 1);
930
 
}
931
 
 
932
 
static uint8_t musb_read_fifo(MUSBEndPoint *ep)
933
 
{
934
 
    uint8_t value;
935
 
    if (ep->fifolen[1] >= 64) {
936
 
        /* We have a FIFO underrun */
937
 
        TRACE("EP%d FIFO is now empty, stop reading", ep->epnum);
938
 
        return 0x00000000;
939
 
    }
940
 
    /* In DMA mode clear RXPKTRDY and set REQPKT automatically
941
 
     * (if AUTOREQ is set) */
942
 
 
943
 
    ep->csr[1] &= ~MGC_M_RXCSR_FIFOFULL;
944
 
    value=ep->buf[1][ep->fifostart[1] + ep->fifolen[1] ++];
945
 
    TRACE("EP%d 0x%02x, %d", ep->epnum, value, ep->fifolen[1] );
946
 
    return value;
947
 
}
948
 
 
949
 
static void musb_write_fifo(MUSBEndPoint *ep, uint8_t value)
950
 
{
951
 
    TRACE("EP%d = %02x", ep->epnum, value);
952
 
    if (ep->fifolen[0] >= 64) {
953
 
        /* We have a FIFO overrun */
954
 
        TRACE("EP%d FIFO exceeded 64 bytes, stop feeding data", ep->epnum);
955
 
        return;
956
 
     }
957
 
 
958
 
     ep->buf[0][ep->fifostart[0] + ep->fifolen[0] ++] = value;
959
 
     ep->csr[0] |= MGC_M_TXCSR_FIFONOTEMPTY;
960
 
}
961
 
 
962
 
static void musb_ep_frame_cancel(MUSBEndPoint *ep, int dir)
963
 
{
964
 
    if (ep->intv_timer[dir])
965
 
        timer_del(ep->intv_timer[dir]);
966
 
}
967
 
 
968
 
/* Bus control */
969
 
static uint8_t musb_busctl_readb(void *opaque, int ep, int addr)
970
 
{
971
 
    MUSBState *s = (MUSBState *) opaque;
972
 
 
973
 
    switch (addr) {
974
 
    /* For USB2.0 HS hubs only */
975
 
    case MUSB_HDRC_TXHUBADDR:
976
 
        return s->ep[ep].haddr[0];
977
 
    case MUSB_HDRC_TXHUBPORT:
978
 
        return s->ep[ep].hport[0];
979
 
    case MUSB_HDRC_RXHUBADDR:
980
 
        return s->ep[ep].haddr[1];
981
 
    case MUSB_HDRC_RXHUBPORT:
982
 
        return s->ep[ep].hport[1];
983
 
 
984
 
    default:
985
 
        TRACE("unknown register 0x%02x", addr);
986
 
        return 0x00;
987
 
    };
988
 
}
989
 
 
990
 
static void musb_busctl_writeb(void *opaque, int ep, int addr, uint8_t value)
991
 
{
992
 
    MUSBState *s = (MUSBState *) opaque;
993
 
 
994
 
    switch (addr) {
995
 
    case MUSB_HDRC_TXFUNCADDR:
996
 
        s->ep[ep].faddr[0] = value;
997
 
        break;
998
 
    case MUSB_HDRC_RXFUNCADDR:
999
 
        s->ep[ep].faddr[1] = value;
1000
 
        break;
1001
 
    case MUSB_HDRC_TXHUBADDR:
1002
 
        s->ep[ep].haddr[0] = value;
1003
 
        break;
1004
 
    case MUSB_HDRC_TXHUBPORT:
1005
 
        s->ep[ep].hport[0] = value;
1006
 
        break;
1007
 
    case MUSB_HDRC_RXHUBADDR:
1008
 
        s->ep[ep].haddr[1] = value;
1009
 
        break;
1010
 
    case MUSB_HDRC_RXHUBPORT:
1011
 
        s->ep[ep].hport[1] = value;
1012
 
        break;
1013
 
 
1014
 
    default:
1015
 
        TRACE("unknown register 0x%02x", addr);
1016
 
        break;
1017
 
    };
1018
 
}
1019
 
 
1020
 
static uint16_t musb_busctl_readh(void *opaque, int ep, int addr)
1021
 
{
1022
 
    MUSBState *s = (MUSBState *) opaque;
1023
 
 
1024
 
    switch (addr) {
1025
 
    case MUSB_HDRC_TXFUNCADDR:
1026
 
        return s->ep[ep].faddr[0];
1027
 
    case MUSB_HDRC_RXFUNCADDR:
1028
 
        return s->ep[ep].faddr[1];
1029
 
 
1030
 
    default:
1031
 
        return musb_busctl_readb(s, ep, addr) |
1032
 
                (musb_busctl_readb(s, ep, addr | 1) << 8);
1033
 
    };
1034
 
}
1035
 
 
1036
 
static void musb_busctl_writeh(void *opaque, int ep, int addr, uint16_t value)
1037
 
{
1038
 
    MUSBState *s = (MUSBState *) opaque;
1039
 
 
1040
 
    switch (addr) {
1041
 
    case MUSB_HDRC_TXFUNCADDR:
1042
 
        s->ep[ep].faddr[0] = value;
1043
 
        break;
1044
 
    case MUSB_HDRC_RXFUNCADDR:
1045
 
        s->ep[ep].faddr[1] = value;
1046
 
        break;
1047
 
 
1048
 
    default:
1049
 
        musb_busctl_writeb(s, ep, addr, value & 0xff);
1050
 
        musb_busctl_writeb(s, ep, addr | 1, value >> 8);
1051
 
    };
1052
 
}
1053
 
 
1054
 
/* Endpoint control */
1055
 
static uint8_t musb_ep_readb(void *opaque, int ep, int addr)
1056
 
{
1057
 
    MUSBState *s = (MUSBState *) opaque;
1058
 
 
1059
 
    switch (addr) {
1060
 
    case MUSB_HDRC_TXTYPE:
1061
 
        return s->ep[ep].type[0];
1062
 
    case MUSB_HDRC_TXINTERVAL:
1063
 
        return s->ep[ep].interval[0];
1064
 
    case MUSB_HDRC_RXTYPE:
1065
 
        return s->ep[ep].type[1];
1066
 
    case MUSB_HDRC_RXINTERVAL:
1067
 
        return s->ep[ep].interval[1];
1068
 
    case (MUSB_HDRC_FIFOSIZE & ~1):
1069
 
        return 0x00;
1070
 
    case MUSB_HDRC_FIFOSIZE:
1071
 
        return ep ? s->ep[ep].fifosize : s->ep[ep].config;
1072
 
    case MUSB_HDRC_RXCOUNT:
1073
 
        return s->ep[ep].rxcount;
1074
 
 
1075
 
    default:
1076
 
        TRACE("unknown register 0x%02x", addr);
1077
 
        return 0x00;
1078
 
    };
1079
 
}
1080
 
 
1081
 
static void musb_ep_writeb(void *opaque, int ep, int addr, uint8_t value)
1082
 
{
1083
 
    MUSBState *s = (MUSBState *) opaque;
1084
 
 
1085
 
    switch (addr) {
1086
 
    case MUSB_HDRC_TXTYPE:
1087
 
        s->ep[ep].type[0] = value;
1088
 
        break;
1089
 
    case MUSB_HDRC_TXINTERVAL:
1090
 
        s->ep[ep].interval[0] = value;
1091
 
        musb_ep_frame_cancel(&s->ep[ep], 0);
1092
 
        break;
1093
 
    case MUSB_HDRC_RXTYPE:
1094
 
        s->ep[ep].type[1] = value;
1095
 
        break;
1096
 
    case MUSB_HDRC_RXINTERVAL:
1097
 
        s->ep[ep].interval[1] = value;
1098
 
        musb_ep_frame_cancel(&s->ep[ep], 1);
1099
 
        break;
1100
 
    case (MUSB_HDRC_FIFOSIZE & ~1):
1101
 
        break;
1102
 
    case MUSB_HDRC_FIFOSIZE:
1103
 
        TRACE("somebody messes with fifosize (now %i bytes)", value);
1104
 
        s->ep[ep].fifosize = value;
1105
 
        break;
1106
 
    default:
1107
 
        TRACE("unknown register 0x%02x", addr);
1108
 
        break;
1109
 
    };
1110
 
}
1111
 
 
1112
 
static uint16_t musb_ep_readh(void *opaque, int ep, int addr)
1113
 
{
1114
 
    MUSBState *s = (MUSBState *) opaque;
1115
 
    uint16_t ret;
1116
 
 
1117
 
    switch (addr) {
1118
 
    case MUSB_HDRC_TXMAXP:
1119
 
        return s->ep[ep].maxp[0];
1120
 
    case MUSB_HDRC_TXCSR:
1121
 
        return s->ep[ep].csr[0];
1122
 
    case MUSB_HDRC_RXMAXP:
1123
 
        return s->ep[ep].maxp[1];
1124
 
    case MUSB_HDRC_RXCSR:
1125
 
        ret = s->ep[ep].csr[1];
1126
 
 
1127
 
        /* TODO: This and other bits probably depend on
1128
 
         * ep->csr[1] & MGC_M_RXCSR_AUTOCLEAR.  */
1129
 
        if (s->ep[ep].csr[1] & MGC_M_RXCSR_AUTOCLEAR)
1130
 
            s->ep[ep].csr[1] &= ~MGC_M_RXCSR_RXPKTRDY;
1131
 
 
1132
 
        return ret;
1133
 
    case MUSB_HDRC_RXCOUNT:
1134
 
        return s->ep[ep].rxcount;
1135
 
 
1136
 
    default:
1137
 
        return musb_ep_readb(s, ep, addr) |
1138
 
                (musb_ep_readb(s, ep, addr | 1) << 8);
1139
 
    };
1140
 
}
1141
 
 
1142
 
static void musb_ep_writeh(void *opaque, int ep, int addr, uint16_t value)
1143
 
{
1144
 
    MUSBState *s = (MUSBState *) opaque;
1145
 
 
1146
 
    switch (addr) {
1147
 
    case MUSB_HDRC_TXMAXP:
1148
 
        s->ep[ep].maxp[0] = value;
1149
 
        break;
1150
 
    case MUSB_HDRC_TXCSR:
1151
 
        if (ep) {
1152
 
            s->ep[ep].csr[0] &= value & 0xa6;
1153
 
            s->ep[ep].csr[0] |= value & 0xff59;
1154
 
        } else {
1155
 
            s->ep[ep].csr[0] &= value & 0x85;
1156
 
            s->ep[ep].csr[0] |= value & 0xf7a;
1157
 
        }
1158
 
 
1159
 
        musb_ep_frame_cancel(&s->ep[ep], 0);
1160
 
 
1161
 
        if ((ep && (value & MGC_M_TXCSR_FLUSHFIFO)) ||
1162
 
                        (!ep && (value & MGC_M_CSR0_FLUSHFIFO))) {
1163
 
            s->ep[ep].fifolen[0] = 0;
1164
 
            s->ep[ep].fifostart[0] = 0;
1165
 
            if (ep)
1166
 
                s->ep[ep].csr[0] &=
1167
 
                        ~(MGC_M_TXCSR_FIFONOTEMPTY | MGC_M_TXCSR_TXPKTRDY);
1168
 
            else
1169
 
                s->ep[ep].csr[0] &=
1170
 
                        ~(MGC_M_CSR0_TXPKTRDY | MGC_M_CSR0_RXPKTRDY);
1171
 
        }
1172
 
        if (
1173
 
                        (ep &&
1174
 
#ifdef CLEAR_NAK
1175
 
                         (value & MGC_M_TXCSR_TXPKTRDY) &&
1176
 
                         !(value & MGC_M_TXCSR_H_NAKTIMEOUT)) ||
1177
 
#else
1178
 
                         (value & MGC_M_TXCSR_TXPKTRDY)) ||
1179
 
#endif
1180
 
                        (!ep &&
1181
 
#ifdef CLEAR_NAK
1182
 
                         (value & MGC_M_CSR0_TXPKTRDY) &&
1183
 
                         !(value & MGC_M_CSR0_H_NAKTIMEOUT)))
1184
 
#else
1185
 
                         (value & MGC_M_CSR0_TXPKTRDY)))
1186
 
#endif
1187
 
            musb_tx_rdy(s, ep);
1188
 
        if (!ep &&
1189
 
                        (value & MGC_M_CSR0_H_REQPKT) &&
1190
 
#ifdef CLEAR_NAK
1191
 
                        !(value & (MGC_M_CSR0_H_NAKTIMEOUT |
1192
 
                                        MGC_M_CSR0_RXPKTRDY)))
1193
 
#else
1194
 
                        !(value & MGC_M_CSR0_RXPKTRDY))
1195
 
#endif
1196
 
            musb_rx_req(s, ep);
1197
 
        break;
1198
 
 
1199
 
    case MUSB_HDRC_RXMAXP:
1200
 
        s->ep[ep].maxp[1] = value;
1201
 
        break;
1202
 
    case MUSB_HDRC_RXCSR:
1203
 
        /* (DMA mode only) */
1204
 
        if (
1205
 
                (value & MGC_M_RXCSR_H_AUTOREQ) &&
1206
 
                !(value & MGC_M_RXCSR_RXPKTRDY) &&
1207
 
                (s->ep[ep].csr[1] & MGC_M_RXCSR_RXPKTRDY))
1208
 
            value |= MGC_M_RXCSR_H_REQPKT;
1209
 
 
1210
 
        s->ep[ep].csr[1] &= 0x102 | (value & 0x4d);
1211
 
        s->ep[ep].csr[1] |= value & 0xfeb0;
1212
 
 
1213
 
        musb_ep_frame_cancel(&s->ep[ep], 1);
1214
 
 
1215
 
        if (value & MGC_M_RXCSR_FLUSHFIFO) {
1216
 
            s->ep[ep].fifolen[1] = 0;
1217
 
            s->ep[ep].fifostart[1] = 0;
1218
 
            s->ep[ep].csr[1] &= ~(MGC_M_RXCSR_FIFOFULL | MGC_M_RXCSR_RXPKTRDY);
1219
 
            /* If double buffering and we have two packets ready, flush
1220
 
             * only the first one and set up the fifo at the second packet.  */
1221
 
        }
1222
 
#ifdef CLEAR_NAK
1223
 
        if ((value & MGC_M_RXCSR_H_REQPKT) && !(value & MGC_M_RXCSR_DATAERROR))
1224
 
#else
1225
 
        if (value & MGC_M_RXCSR_H_REQPKT)
1226
 
#endif
1227
 
            musb_rx_req(s, ep);
1228
 
        break;
1229
 
    case MUSB_HDRC_RXCOUNT:
1230
 
        s->ep[ep].rxcount = value;
1231
 
        break;
1232
 
 
1233
 
    default:
1234
 
        musb_ep_writeb(s, ep, addr, value & 0xff);
1235
 
        musb_ep_writeb(s, ep, addr | 1, value >> 8);
1236
 
    };
1237
 
}
1238
 
 
1239
 
/* Generic control */
1240
 
static uint32_t musb_readb(void *opaque, hwaddr addr)
1241
 
{
1242
 
    MUSBState *s = (MUSBState *) opaque;
1243
 
    int ep, i;
1244
 
    uint8_t ret;
1245
 
 
1246
 
    switch (addr) {
1247
 
    case MUSB_HDRC_FADDR:
1248
 
        return s->faddr;
1249
 
    case MUSB_HDRC_POWER:
1250
 
        return s->power;
1251
 
    case MUSB_HDRC_INTRUSB:
1252
 
        ret = s->intr;
1253
 
        for (i = 0; i < sizeof(ret) * 8; i ++)
1254
 
            if (ret & (1 << i))
1255
 
                musb_intr_set(s, i, 0);
1256
 
        return ret;
1257
 
    case MUSB_HDRC_INTRUSBE:
1258
 
        return s->mask;
1259
 
    case MUSB_HDRC_INDEX:
1260
 
        return s->idx;
1261
 
    case MUSB_HDRC_TESTMODE:
1262
 
        return 0x00;
1263
 
 
1264
 
    case MUSB_HDRC_EP_IDX ... (MUSB_HDRC_EP_IDX + 0xf):
1265
 
        return musb_ep_readb(s, s->idx, addr & 0xf);
1266
 
 
1267
 
    case MUSB_HDRC_DEVCTL:
1268
 
        return s->devctl;
1269
 
 
1270
 
    case MUSB_HDRC_TXFIFOSZ:
1271
 
    case MUSB_HDRC_RXFIFOSZ:
1272
 
    case MUSB_HDRC_VCTRL:
1273
 
        /* TODO */
1274
 
        return 0x00;
1275
 
 
1276
 
    case MUSB_HDRC_HWVERS:
1277
 
        return (1 << 10) | 400;
1278
 
 
1279
 
    case (MUSB_HDRC_VCTRL | 1):
1280
 
    case (MUSB_HDRC_HWVERS | 1):
1281
 
    case (MUSB_HDRC_DEVCTL | 1):
1282
 
        return 0x00;
1283
 
 
1284
 
    case MUSB_HDRC_BUSCTL ... (MUSB_HDRC_BUSCTL + 0x7f):
1285
 
        ep = (addr >> 3) & 0xf;
1286
 
        return musb_busctl_readb(s, ep, addr & 0x7);
1287
 
 
1288
 
    case MUSB_HDRC_EP ... (MUSB_HDRC_EP + 0xff):
1289
 
        ep = (addr >> 4) & 0xf;
1290
 
        return musb_ep_readb(s, ep, addr & 0xf);
1291
 
 
1292
 
    case MUSB_HDRC_FIFO ... (MUSB_HDRC_FIFO + 0x3f):
1293
 
        ep = ((addr - MUSB_HDRC_FIFO) >> 2) & 0xf;
1294
 
        return musb_read_fifo(s->ep + ep);
1295
 
 
1296
 
    default:
1297
 
        TRACE("unknown register 0x%02x", (int) addr);
1298
 
        return 0x00;
1299
 
    };
1300
 
}
1301
 
 
1302
 
static void musb_writeb(void *opaque, hwaddr addr, uint32_t value)
1303
 
{
1304
 
    MUSBState *s = (MUSBState *) opaque;
1305
 
    int ep;
1306
 
 
1307
 
    switch (addr) {
1308
 
    case MUSB_HDRC_FADDR:
1309
 
        s->faddr = value & 0x7f;
1310
 
        break;
1311
 
    case MUSB_HDRC_POWER:
1312
 
        s->power = (value & 0xef) | (s->power & 0x10);
1313
 
        /* MGC_M_POWER_RESET is also read-only in Peripheral Mode */
1314
 
        if ((value & MGC_M_POWER_RESET) && s->port.dev) {
1315
 
            usb_device_reset(s->port.dev);
1316
 
            /* Negotiate high-speed operation if MGC_M_POWER_HSENAB is set.  */
1317
 
            if ((value & MGC_M_POWER_HSENAB) &&
1318
 
                            s->port.dev->speed == USB_SPEED_HIGH)
1319
 
                s->power |= MGC_M_POWER_HSMODE; /* Success */
1320
 
            /* Restart frame counting.  */
1321
 
        }
1322
 
        if (value & MGC_M_POWER_SUSPENDM) {
1323
 
            /* When all transfers finish, suspend and if MGC_M_POWER_ENSUSPEND
1324
 
             * is set, also go into low power mode.  Frame counting stops.  */
1325
 
            /* XXX: Cleared when the interrupt register is read */
1326
 
        }
1327
 
        if (value & MGC_M_POWER_RESUME) {
1328
 
            /* Wait 20ms and signal resuming on the bus.  Frame counting
1329
 
             * restarts.  */
1330
 
        }
1331
 
        break;
1332
 
    case MUSB_HDRC_INTRUSB:
1333
 
        break;
1334
 
    case MUSB_HDRC_INTRUSBE:
1335
 
        s->mask = value & 0xff;
1336
 
        break;
1337
 
    case MUSB_HDRC_INDEX:
1338
 
        s->idx = value & 0xf;
1339
 
        break;
1340
 
    case MUSB_HDRC_TESTMODE:
1341
 
        break;
1342
 
 
1343
 
    case MUSB_HDRC_EP_IDX ... (MUSB_HDRC_EP_IDX + 0xf):
1344
 
        musb_ep_writeb(s, s->idx, addr & 0xf, value);
1345
 
        break;
1346
 
 
1347
 
    case MUSB_HDRC_DEVCTL:
1348
 
        s->session = !!(value & MGC_M_DEVCTL_SESSION);
1349
 
        musb_session_update(s,
1350
 
                        !!s->port.dev,
1351
 
                        !!(s->devctl & MGC_M_DEVCTL_SESSION));
1352
 
 
1353
 
        /* It seems this is the only R/W bit in this register?  */
1354
 
        s->devctl &= ~MGC_M_DEVCTL_SESSION;
1355
 
        s->devctl |= value & MGC_M_DEVCTL_SESSION;
1356
 
        break;
1357
 
 
1358
 
    case MUSB_HDRC_TXFIFOSZ:
1359
 
    case MUSB_HDRC_RXFIFOSZ:
1360
 
    case MUSB_HDRC_VCTRL:
1361
 
        /* TODO */
1362
 
        break;
1363
 
 
1364
 
    case (MUSB_HDRC_VCTRL | 1):
1365
 
    case (MUSB_HDRC_DEVCTL | 1):
1366
 
        break;
1367
 
 
1368
 
    case MUSB_HDRC_BUSCTL ... (MUSB_HDRC_BUSCTL + 0x7f):
1369
 
        ep = (addr >> 3) & 0xf;
1370
 
        musb_busctl_writeb(s, ep, addr & 0x7, value);
1371
 
        break;
1372
 
 
1373
 
    case MUSB_HDRC_EP ... (MUSB_HDRC_EP + 0xff):
1374
 
        ep = (addr >> 4) & 0xf;
1375
 
        musb_ep_writeb(s, ep, addr & 0xf, value);
1376
 
        break;
1377
 
 
1378
 
    case MUSB_HDRC_FIFO ... (MUSB_HDRC_FIFO + 0x3f):
1379
 
        ep = ((addr - MUSB_HDRC_FIFO) >> 2) & 0xf;
1380
 
        musb_write_fifo(s->ep + ep, value & 0xff);
1381
 
        break;
1382
 
 
1383
 
    default:
1384
 
        TRACE("unknown register 0x%02x", (int) addr);
1385
 
        break;
1386
 
    };
1387
 
}
1388
 
 
1389
 
static uint32_t musb_readh(void *opaque, hwaddr addr)
1390
 
{
1391
 
    MUSBState *s = (MUSBState *) opaque;
1392
 
    int ep, i;
1393
 
    uint16_t ret;
1394
 
 
1395
 
    switch (addr) {
1396
 
    case MUSB_HDRC_INTRTX:
1397
 
        ret = s->tx_intr;
1398
 
        /* Auto clear */
1399
 
        for (i = 0; i < sizeof(ret) * 8; i ++)
1400
 
            if (ret & (1 << i))
1401
 
                musb_tx_intr_set(s, i, 0);
1402
 
        return ret;
1403
 
    case MUSB_HDRC_INTRRX:
1404
 
        ret = s->rx_intr;
1405
 
        /* Auto clear */
1406
 
        for (i = 0; i < sizeof(ret) * 8; i ++)
1407
 
            if (ret & (1 << i))
1408
 
                musb_rx_intr_set(s, i, 0);
1409
 
        return ret;
1410
 
    case MUSB_HDRC_INTRTXE:
1411
 
        return s->tx_mask;
1412
 
    case MUSB_HDRC_INTRRXE:
1413
 
        return s->rx_mask;
1414
 
 
1415
 
    case MUSB_HDRC_FRAME:
1416
 
        /* TODO */
1417
 
        return 0x0000;
1418
 
    case MUSB_HDRC_TXFIFOADDR:
1419
 
        return s->ep[s->idx].fifoaddr[0];
1420
 
    case MUSB_HDRC_RXFIFOADDR:
1421
 
        return s->ep[s->idx].fifoaddr[1];
1422
 
 
1423
 
    case MUSB_HDRC_EP_IDX ... (MUSB_HDRC_EP_IDX + 0xf):
1424
 
        return musb_ep_readh(s, s->idx, addr & 0xf);
1425
 
 
1426
 
    case MUSB_HDRC_BUSCTL ... (MUSB_HDRC_BUSCTL + 0x7f):
1427
 
        ep = (addr >> 3) & 0xf;
1428
 
        return musb_busctl_readh(s, ep, addr & 0x7);
1429
 
 
1430
 
    case MUSB_HDRC_EP ... (MUSB_HDRC_EP + 0xff):
1431
 
        ep = (addr >> 4) & 0xf;
1432
 
        return musb_ep_readh(s, ep, addr & 0xf);
1433
 
 
1434
 
    case MUSB_HDRC_FIFO ... (MUSB_HDRC_FIFO + 0x3f):
1435
 
        ep = ((addr - MUSB_HDRC_FIFO) >> 2) & 0xf;
1436
 
        return (musb_read_fifo(s->ep + ep) | musb_read_fifo(s->ep + ep) << 8);
1437
 
 
1438
 
    default:
1439
 
        return musb_readb(s, addr) | (musb_readb(s, addr | 1) << 8);
1440
 
    };
1441
 
}
1442
 
 
1443
 
static void musb_writeh(void *opaque, hwaddr addr, uint32_t value)
1444
 
{
1445
 
    MUSBState *s = (MUSBState *) opaque;
1446
 
    int ep;
1447
 
 
1448
 
    switch (addr) {
1449
 
    case MUSB_HDRC_INTRTXE:
1450
 
        s->tx_mask = value;
1451
 
        /* XXX: the masks seem to apply on the raising edge like with
1452
 
         * edge-triggered interrupts, thus no need to update.  I may be
1453
 
         * wrong though.  */
1454
 
        break;
1455
 
    case MUSB_HDRC_INTRRXE:
1456
 
        s->rx_mask = value;
1457
 
        break;
1458
 
 
1459
 
    case MUSB_HDRC_FRAME:
1460
 
        /* TODO */
1461
 
        break;
1462
 
    case MUSB_HDRC_TXFIFOADDR:
1463
 
        s->ep[s->idx].fifoaddr[0] = value;
1464
 
        s->ep[s->idx].buf[0] =
1465
 
                s->buf + ((value << 3) & 0x7ff );
1466
 
        break;
1467
 
    case MUSB_HDRC_RXFIFOADDR:
1468
 
        s->ep[s->idx].fifoaddr[1] = value;
1469
 
        s->ep[s->idx].buf[1] =
1470
 
                s->buf + ((value << 3) & 0x7ff);
1471
 
        break;
1472
 
 
1473
 
    case MUSB_HDRC_EP_IDX ... (MUSB_HDRC_EP_IDX + 0xf):
1474
 
        musb_ep_writeh(s, s->idx, addr & 0xf, value);
1475
 
        break;
1476
 
 
1477
 
    case MUSB_HDRC_BUSCTL ... (MUSB_HDRC_BUSCTL + 0x7f):
1478
 
        ep = (addr >> 3) & 0xf;
1479
 
        musb_busctl_writeh(s, ep, addr & 0x7, value);
1480
 
        break;
1481
 
 
1482
 
    case MUSB_HDRC_EP ... (MUSB_HDRC_EP + 0xff):
1483
 
        ep = (addr >> 4) & 0xf;
1484
 
        musb_ep_writeh(s, ep, addr & 0xf, value);
1485
 
        break;
1486
 
 
1487
 
    case MUSB_HDRC_FIFO ... (MUSB_HDRC_FIFO + 0x3f):
1488
 
        ep = ((addr - MUSB_HDRC_FIFO) >> 2) & 0xf;
1489
 
        musb_write_fifo(s->ep + ep, value & 0xff);
1490
 
        musb_write_fifo(s->ep + ep, (value >> 8) & 0xff);
1491
 
        break;
1492
 
 
1493
 
    default:
1494
 
        musb_writeb(s, addr, value & 0xff);
1495
 
        musb_writeb(s, addr | 1, value >> 8);
1496
 
    };
1497
 
}
1498
 
 
1499
 
static uint32_t musb_readw(void *opaque, hwaddr addr)
1500
 
{
1501
 
    MUSBState *s = (MUSBState *) opaque;
1502
 
    int ep;
1503
 
 
1504
 
    switch (addr) {
1505
 
    case MUSB_HDRC_FIFO ... (MUSB_HDRC_FIFO + 0x3f):
1506
 
        ep = ((addr - MUSB_HDRC_FIFO) >> 2) & 0xf;
1507
 
        return ( musb_read_fifo(s->ep + ep)       |
1508
 
                 musb_read_fifo(s->ep + ep) << 8  |
1509
 
                 musb_read_fifo(s->ep + ep) << 16 |
1510
 
                 musb_read_fifo(s->ep + ep) << 24 );
1511
 
    default:
1512
 
        TRACE("unknown register 0x%02x", (int) addr);
1513
 
        return 0x00000000;
1514
 
    };
1515
 
}
1516
 
 
1517
 
static void musb_writew(void *opaque, hwaddr addr, uint32_t value)
1518
 
{
1519
 
    MUSBState *s = (MUSBState *) opaque;
1520
 
    int ep;
1521
 
 
1522
 
    switch (addr) {
1523
 
    case MUSB_HDRC_FIFO ... (MUSB_HDRC_FIFO + 0x3f):
1524
 
        ep = ((addr - MUSB_HDRC_FIFO) >> 2) & 0xf;
1525
 
        musb_write_fifo(s->ep + ep, value & 0xff);
1526
 
        musb_write_fifo(s->ep + ep, (value >> 8 ) & 0xff);
1527
 
        musb_write_fifo(s->ep + ep, (value >> 16) & 0xff);
1528
 
        musb_write_fifo(s->ep + ep, (value >> 24) & 0xff);
1529
 
            break;
1530
 
    default:
1531
 
        TRACE("unknown register 0x%02x", (int) addr);
1532
 
        break;
1533
 
    };
1534
 
}
1535
 
 
1536
 
CPUReadMemoryFunc * const musb_read[] = {
1537
 
    musb_readb,
1538
 
    musb_readh,
1539
 
    musb_readw,
1540
 
};
1541
 
 
1542
 
CPUWriteMemoryFunc * const musb_write[] = {
1543
 
    musb_writeb,
1544
 
    musb_writeh,
1545
 
    musb_writew,
1546
 
};