projects / qemu / blob
? search:


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