meson: convert qapi-specific to meson
[qemu.git] / hw / usb / hcd-dwc2.c
1 /*
2 * dwc-hsotg (dwc2) USB host controller emulation
3 *
4 * Based on hw/usb/hcd-ehci.c and hw/usb/hcd-ohci.c
5 *
6 * Note that to use this emulation with the dwc-otg driver in the
7 * Raspbian kernel, you must pass the option "dwc_otg.fiq_fsm_enable=0"
8 * on the kernel command line.
9 *
10 * Some useful documentation used to develop this emulation can be
11 * found online (as of April 2020) at:
12 *
13 * http://www.capital-micro.com/PDF/CME-M7_Family_User_Guide_EN.pdf
14 * which has a pretty complete description of the controller starting
15 * on page 370.
16 *
17 * https://sourceforge.net/p/wive-ng/wive-ng-mt/ci/master/tree/docs/DataSheets/RT3050_5x_V2.0_081408_0902.pdf
18 * which has a description of the controller registers starting on
19 * page 130.
20 *
21 * Copyright (c) 2020 Paul Zimmerman <pauldzim@gmail.com>
22 *
23 * This program is free software; you can redistribute it and/or modify
24 * it under the terms of the GNU General Public License as published by
25 * the Free Software Foundation; either version 2 of the License, or
26 * (at your option) any later version.
27 *
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31 * GNU General Public License for more details.
32 */
33
34 #include "qemu/osdep.h"
35 #include "qemu/units.h"
36 #include "qapi/error.h"
37 #include "hw/usb/dwc2-regs.h"
38 #include "hw/usb/hcd-dwc2.h"
39 #include "migration/vmstate.h"
40 #include "trace.h"
41 #include "qemu/log.h"
42 #include "qemu/error-report.h"
43 #include "qemu/main-loop.h"
44 #include "hw/qdev-properties.h"
45
46 #define USB_HZ_FS 12000000
47 #define USB_HZ_HS 96000000
48 #define USB_FRMINTVL 12000
49
50 /* nifty macros from Arnon's EHCI version */
51 #define get_field(data, field) \
52 (((data) & field##_MASK) >> field##_SHIFT)
53
54 #define set_field(data, newval, field) do { \
55 uint32_t val = *(data); \
56 val &= ~field##_MASK; \
57 val |= ((newval) << field##_SHIFT) & field##_MASK; \
58 *(data) = val; \
59 } while (0)
60
61 #define get_bit(data, bitmask) \
62 (!!((data) & (bitmask)))
63
64 /* update irq line */
65 static inline void dwc2_update_irq(DWC2State *s)
66 {
67 static int oldlevel;
68 int level = 0;
69
70 if ((s->gintsts & s->gintmsk) && (s->gahbcfg & GAHBCFG_GLBL_INTR_EN)) {
71 level = 1;
72 }
73 if (level != oldlevel) {
74 oldlevel = level;
75 trace_usb_dwc2_update_irq(level);
76 qemu_set_irq(s->irq, level);
77 }
78 }
79
80 /* flag interrupt condition */
81 static inline void dwc2_raise_global_irq(DWC2State *s, uint32_t intr)
82 {
83 if (!(s->gintsts & intr)) {
84 s->gintsts |= intr;
85 trace_usb_dwc2_raise_global_irq(intr);
86 dwc2_update_irq(s);
87 }
88 }
89
90 static inline void dwc2_lower_global_irq(DWC2State *s, uint32_t intr)
91 {
92 if (s->gintsts & intr) {
93 s->gintsts &= ~intr;
94 trace_usb_dwc2_lower_global_irq(intr);
95 dwc2_update_irq(s);
96 }
97 }
98
99 static inline void dwc2_raise_host_irq(DWC2State *s, uint32_t host_intr)
100 {
101 if (!(s->haint & host_intr)) {
102 s->haint |= host_intr;
103 s->haint &= 0xffff;
104 trace_usb_dwc2_raise_host_irq(host_intr);
105 if (s->haint & s->haintmsk) {
106 dwc2_raise_global_irq(s, GINTSTS_HCHINT);
107 }
108 }
109 }
110
111 static inline void dwc2_lower_host_irq(DWC2State *s, uint32_t host_intr)
112 {
113 if (s->haint & host_intr) {
114 s->haint &= ~host_intr;
115 trace_usb_dwc2_lower_host_irq(host_intr);
116 if (!(s->haint & s->haintmsk)) {
117 dwc2_lower_global_irq(s, GINTSTS_HCHINT);
118 }
119 }
120 }
121
122 static inline void dwc2_update_hc_irq(DWC2State *s, int index)
123 {
124 uint32_t host_intr = 1 << (index >> 3);
125
126 if (s->hreg1[index + 2] & s->hreg1[index + 3]) {
127 dwc2_raise_host_irq(s, host_intr);
128 } else {
129 dwc2_lower_host_irq(s, host_intr);
130 }
131 }
132
133 /* set a timer for EOF */
134 static void dwc2_eof_timer(DWC2State *s)
135 {
136 timer_mod(s->eof_timer, s->sof_time + s->usb_frame_time);
137 }
138
139 /* Set a timer for EOF and generate SOF event */
140 static void dwc2_sof(DWC2State *s)
141 {
142 s->sof_time += s->usb_frame_time;
143 trace_usb_dwc2_sof(s->sof_time);
144 dwc2_eof_timer(s);
145 dwc2_raise_global_irq(s, GINTSTS_SOF);
146 }
147
148 /* Do frame processing on frame boundary */
149 static void dwc2_frame_boundary(void *opaque)
150 {
151 DWC2State *s = opaque;
152 int64_t now;
153 uint16_t frcnt;
154
155 now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
156
157 /* Frame boundary, so do EOF stuff here */
158
159 /* Increment frame number */
160 frcnt = (uint16_t)((now - s->sof_time) / s->fi);
161 s->frame_number = (s->frame_number + frcnt) & 0xffff;
162 s->hfnum = s->frame_number & HFNUM_MAX_FRNUM;
163
164 /* Do SOF stuff here */
165 dwc2_sof(s);
166 }
167
168 /* Start sending SOF tokens on the USB bus */
169 static void dwc2_bus_start(DWC2State *s)
170 {
171 trace_usb_dwc2_bus_start();
172 s->sof_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
173 dwc2_eof_timer(s);
174 }
175
176 /* Stop sending SOF tokens on the USB bus */
177 static void dwc2_bus_stop(DWC2State *s)
178 {
179 trace_usb_dwc2_bus_stop();
180 timer_del(s->eof_timer);
181 }
182
183 static USBDevice *dwc2_find_device(DWC2State *s, uint8_t addr)
184 {
185 USBDevice *dev;
186
187 trace_usb_dwc2_find_device(addr);
188
189 if (!(s->hprt0 & HPRT0_ENA)) {
190 trace_usb_dwc2_port_disabled(0);
191 } else {
192 dev = usb_find_device(&s->uport, addr);
193 if (dev != NULL) {
194 trace_usb_dwc2_device_found(0);
195 return dev;
196 }
197 }
198
199 trace_usb_dwc2_device_not_found();
200 return NULL;
201 }
202
203 static const char *pstatus[] = {
204 "USB_RET_SUCCESS", "USB_RET_NODEV", "USB_RET_NAK", "USB_RET_STALL",
205 "USB_RET_BABBLE", "USB_RET_IOERROR", "USB_RET_ASYNC",
206 "USB_RET_ADD_TO_QUEUE", "USB_RET_REMOVE_FROM_QUEUE"
207 };
208
209 static uint32_t pintr[] = {
210 HCINTMSK_XFERCOMPL, HCINTMSK_XACTERR, HCINTMSK_NAK, HCINTMSK_STALL,
211 HCINTMSK_BBLERR, HCINTMSK_XACTERR, HCINTMSK_XACTERR, HCINTMSK_XACTERR,
212 HCINTMSK_XACTERR
213 };
214
215 static const char *types[] = {
216 "Ctrl", "Isoc", "Bulk", "Intr"
217 };
218
219 static const char *dirs[] = {
220 "Out", "In"
221 };
222
223 static void dwc2_handle_packet(DWC2State *s, uint32_t devadr, USBDevice *dev,
224 USBEndpoint *ep, uint32_t index, bool send)
225 {
226 DWC2Packet *p;
227 uint32_t hcchar = s->hreg1[index];
228 uint32_t hctsiz = s->hreg1[index + 4];
229 uint32_t hcdma = s->hreg1[index + 5];
230 uint32_t chan, epnum, epdir, eptype, mps, pid, pcnt, len, tlen, intr = 0;
231 uint32_t tpcnt, stsidx, actual = 0;
232 bool do_intr = false, done = false;
233
234 epnum = get_field(hcchar, HCCHAR_EPNUM);
235 epdir = get_bit(hcchar, HCCHAR_EPDIR);
236 eptype = get_field(hcchar, HCCHAR_EPTYPE);
237 mps = get_field(hcchar, HCCHAR_MPS);
238 pid = get_field(hctsiz, TSIZ_SC_MC_PID);
239 pcnt = get_field(hctsiz, TSIZ_PKTCNT);
240 len = get_field(hctsiz, TSIZ_XFERSIZE);
241 assert(len <= DWC2_MAX_XFER_SIZE);
242 chan = index >> 3;
243 p = &s->packet[chan];
244
245 trace_usb_dwc2_handle_packet(chan, dev, &p->packet, epnum, types[eptype],
246 dirs[epdir], mps, len, pcnt);
247
248 if (eptype == USB_ENDPOINT_XFER_CONTROL && pid == TSIZ_SC_MC_PID_SETUP) {
249 pid = USB_TOKEN_SETUP;
250 } else {
251 pid = epdir ? USB_TOKEN_IN : USB_TOKEN_OUT;
252 }
253
254 if (send) {
255 tlen = len;
256 if (p->small) {
257 if (tlen > mps) {
258 tlen = mps;
259 }
260 }
261
262 if (pid != USB_TOKEN_IN) {
263 trace_usb_dwc2_memory_read(hcdma, tlen);
264 if (dma_memory_read(&s->dma_as, hcdma,
265 s->usb_buf[chan], tlen) != MEMTX_OK) {
266 qemu_log_mask(LOG_GUEST_ERROR, "%s: dma_memory_read failed\n",
267 __func__);
268 }
269 }
270
271 usb_packet_init(&p->packet);
272 usb_packet_setup(&p->packet, pid, ep, 0, hcdma,
273 pid != USB_TOKEN_IN, true);
274 usb_packet_addbuf(&p->packet, s->usb_buf[chan], tlen);
275 p->async = DWC2_ASYNC_NONE;
276 usb_handle_packet(dev, &p->packet);
277 } else {
278 tlen = p->len;
279 }
280
281 stsidx = -p->packet.status;
282 assert(stsidx < sizeof(pstatus) / sizeof(*pstatus));
283 actual = p->packet.actual_length;
284 trace_usb_dwc2_packet_status(pstatus[stsidx], actual);
285
286 babble:
287 if (p->packet.status != USB_RET_SUCCESS &&
288 p->packet.status != USB_RET_NAK &&
289 p->packet.status != USB_RET_STALL &&
290 p->packet.status != USB_RET_ASYNC) {
291 trace_usb_dwc2_packet_error(pstatus[stsidx]);
292 }
293
294 if (p->packet.status == USB_RET_ASYNC) {
295 trace_usb_dwc2_async_packet(&p->packet, chan, dev, epnum,
296 dirs[epdir], tlen);
297 usb_device_flush_ep_queue(dev, ep);
298 assert(p->async != DWC2_ASYNC_INFLIGHT);
299 p->devadr = devadr;
300 p->epnum = epnum;
301 p->epdir = epdir;
302 p->mps = mps;
303 p->pid = pid;
304 p->index = index;
305 p->pcnt = pcnt;
306 p->len = tlen;
307 p->async = DWC2_ASYNC_INFLIGHT;
308 p->needs_service = false;
309 return;
310 }
311
312 if (p->packet.status == USB_RET_SUCCESS) {
313 if (actual > tlen) {
314 p->packet.status = USB_RET_BABBLE;
315 goto babble;
316 }
317
318 if (pid == USB_TOKEN_IN) {
319 trace_usb_dwc2_memory_write(hcdma, actual);
320 if (dma_memory_write(&s->dma_as, hcdma, s->usb_buf[chan],
321 actual) != MEMTX_OK) {
322 qemu_log_mask(LOG_GUEST_ERROR, "%s: dma_memory_write failed\n",
323 __func__);
324 }
325 }
326
327 tpcnt = actual / mps;
328 if (actual % mps) {
329 tpcnt++;
330 if (pid == USB_TOKEN_IN) {
331 done = true;
332 }
333 }
334
335 pcnt -= tpcnt < pcnt ? tpcnt : pcnt;
336 set_field(&hctsiz, pcnt, TSIZ_PKTCNT);
337 len -= actual < len ? actual : len;
338 set_field(&hctsiz, len, TSIZ_XFERSIZE);
339 s->hreg1[index + 4] = hctsiz;
340 hcdma += actual;
341 s->hreg1[index + 5] = hcdma;
342
343 if (!pcnt || len == 0 || actual == 0) {
344 done = true;
345 }
346 } else {
347 intr |= pintr[stsidx];
348 if (p->packet.status == USB_RET_NAK &&
349 (eptype == USB_ENDPOINT_XFER_CONTROL ||
350 eptype == USB_ENDPOINT_XFER_BULK)) {
351 /*
352 * for ctrl/bulk, automatically retry on NAK,
353 * but send the interrupt anyway
354 */
355 intr &= ~HCINTMSK_RESERVED14_31;
356 s->hreg1[index + 2] |= intr;
357 do_intr = true;
358 } else {
359 intr |= HCINTMSK_CHHLTD;
360 done = true;
361 }
362 }
363
364 usb_packet_cleanup(&p->packet);
365
366 if (done) {
367 hcchar &= ~HCCHAR_CHENA;
368 s->hreg1[index] = hcchar;
369 if (!(intr & HCINTMSK_CHHLTD)) {
370 intr |= HCINTMSK_CHHLTD | HCINTMSK_XFERCOMPL;
371 }
372 intr &= ~HCINTMSK_RESERVED14_31;
373 s->hreg1[index + 2] |= intr;
374 p->needs_service = false;
375 trace_usb_dwc2_packet_done(pstatus[stsidx], actual, len, pcnt);
376 dwc2_update_hc_irq(s, index);
377 return;
378 }
379
380 p->devadr = devadr;
381 p->epnum = epnum;
382 p->epdir = epdir;
383 p->mps = mps;
384 p->pid = pid;
385 p->index = index;
386 p->pcnt = pcnt;
387 p->len = len;
388 p->needs_service = true;
389 trace_usb_dwc2_packet_next(pstatus[stsidx], len, pcnt);
390 if (do_intr) {
391 dwc2_update_hc_irq(s, index);
392 }
393 }
394
395 /* Attach or detach a device on root hub */
396
397 static const char *speeds[] = {
398 "low", "full", "high"
399 };
400
401 static void dwc2_attach(USBPort *port)
402 {
403 DWC2State *s = port->opaque;
404 int hispd = 0;
405
406 trace_usb_dwc2_attach(port);
407 assert(port->index == 0);
408
409 if (!port->dev || !port->dev->attached) {
410 return;
411 }
412
413 assert(port->dev->speed <= USB_SPEED_HIGH);
414 trace_usb_dwc2_attach_speed(speeds[port->dev->speed]);
415 s->hprt0 &= ~HPRT0_SPD_MASK;
416
417 switch (port->dev->speed) {
418 case USB_SPEED_LOW:
419 s->hprt0 |= HPRT0_SPD_LOW_SPEED << HPRT0_SPD_SHIFT;
420 break;
421 case USB_SPEED_FULL:
422 s->hprt0 |= HPRT0_SPD_FULL_SPEED << HPRT0_SPD_SHIFT;
423 break;
424 case USB_SPEED_HIGH:
425 s->hprt0 |= HPRT0_SPD_HIGH_SPEED << HPRT0_SPD_SHIFT;
426 hispd = 1;
427 break;
428 }
429
430 if (hispd) {
431 s->usb_frame_time = NANOSECONDS_PER_SECOND / 8000; /* 125000 */
432 if (NANOSECONDS_PER_SECOND >= USB_HZ_HS) {
433 s->usb_bit_time = NANOSECONDS_PER_SECOND / USB_HZ_HS; /* 10.4 */
434 } else {
435 s->usb_bit_time = 1;
436 }
437 } else {
438 s->usb_frame_time = NANOSECONDS_PER_SECOND / 1000; /* 1000000 */
439 if (NANOSECONDS_PER_SECOND >= USB_HZ_FS) {
440 s->usb_bit_time = NANOSECONDS_PER_SECOND / USB_HZ_FS; /* 83.3 */
441 } else {
442 s->usb_bit_time = 1;
443 }
444 }
445
446 s->fi = USB_FRMINTVL - 1;
447 s->hprt0 |= HPRT0_CONNDET | HPRT0_CONNSTS;
448
449 dwc2_bus_start(s);
450 dwc2_raise_global_irq(s, GINTSTS_PRTINT);
451 }
452
453 static void dwc2_detach(USBPort *port)
454 {
455 DWC2State *s = port->opaque;
456
457 trace_usb_dwc2_detach(port);
458 assert(port->index == 0);
459
460 dwc2_bus_stop(s);
461
462 s->hprt0 &= ~(HPRT0_SPD_MASK | HPRT0_SUSP | HPRT0_ENA | HPRT0_CONNSTS);
463 s->hprt0 |= HPRT0_CONNDET | HPRT0_ENACHG;
464
465 dwc2_raise_global_irq(s, GINTSTS_PRTINT);
466 }
467
468 static void dwc2_child_detach(USBPort *port, USBDevice *child)
469 {
470 trace_usb_dwc2_child_detach(port, child);
471 assert(port->index == 0);
472 }
473
474 static void dwc2_wakeup(USBPort *port)
475 {
476 DWC2State *s = port->opaque;
477
478 trace_usb_dwc2_wakeup(port);
479 assert(port->index == 0);
480
481 if (s->hprt0 & HPRT0_SUSP) {
482 s->hprt0 |= HPRT0_RES;
483 dwc2_raise_global_irq(s, GINTSTS_PRTINT);
484 }
485
486 qemu_bh_schedule(s->async_bh);
487 }
488
489 static void dwc2_async_packet_complete(USBPort *port, USBPacket *packet)
490 {
491 DWC2State *s = port->opaque;
492 DWC2Packet *p;
493 USBDevice *dev;
494 USBEndpoint *ep;
495
496 assert(port->index == 0);
497 p = container_of(packet, DWC2Packet, packet);
498 dev = dwc2_find_device(s, p->devadr);
499 ep = usb_ep_get(dev, p->pid, p->epnum);
500 trace_usb_dwc2_async_packet_complete(port, packet, p->index >> 3, dev,
501 p->epnum, dirs[p->epdir], p->len);
502 assert(p->async == DWC2_ASYNC_INFLIGHT);
503
504 if (packet->status == USB_RET_REMOVE_FROM_QUEUE) {
505 usb_cancel_packet(packet);
506 usb_packet_cleanup(packet);
507 return;
508 }
509
510 dwc2_handle_packet(s, p->devadr, dev, ep, p->index, false);
511
512 p->async = DWC2_ASYNC_FINISHED;
513 qemu_bh_schedule(s->async_bh);
514 }
515
516 static USBPortOps dwc2_port_ops = {
517 .attach = dwc2_attach,
518 .detach = dwc2_detach,
519 .child_detach = dwc2_child_detach,
520 .wakeup = dwc2_wakeup,
521 .complete = dwc2_async_packet_complete,
522 };
523
524 static uint32_t dwc2_get_frame_remaining(DWC2State *s)
525 {
526 uint32_t fr = 0;
527 int64_t tks;
528
529 tks = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) - s->sof_time;
530 if (tks < 0) {
531 tks = 0;
532 }
533
534 /* avoid muldiv if possible */
535 if (tks >= s->usb_frame_time) {
536 goto out;
537 }
538 if (tks < s->usb_bit_time) {
539 fr = s->fi;
540 goto out;
541 }
542
543 /* tks = number of ns since SOF, divided by 83 (fs) or 10 (hs) */
544 tks = tks / s->usb_bit_time;
545 if (tks >= (int64_t)s->fi) {
546 goto out;
547 }
548
549 /* remaining = frame interval minus tks */
550 fr = (uint32_t)((int64_t)s->fi - tks);
551
552 out:
553 return fr;
554 }
555
556 static void dwc2_work_bh(void *opaque)
557 {
558 DWC2State *s = opaque;
559 DWC2Packet *p;
560 USBDevice *dev;
561 USBEndpoint *ep;
562 int64_t t_now, expire_time;
563 int chan;
564 bool found = false;
565
566 trace_usb_dwc2_work_bh();
567 if (s->working) {
568 return;
569 }
570 s->working = true;
571
572 t_now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
573 chan = s->next_chan;
574
575 do {
576 p = &s->packet[chan];
577 if (p->needs_service) {
578 dev = dwc2_find_device(s, p->devadr);
579 ep = usb_ep_get(dev, p->pid, p->epnum);
580 trace_usb_dwc2_work_bh_service(s->next_chan, chan, dev, p->epnum);
581 dwc2_handle_packet(s, p->devadr, dev, ep, p->index, true);
582 found = true;
583 }
584 if (++chan == DWC2_NB_CHAN) {
585 chan = 0;
586 }
587 if (found) {
588 s->next_chan = chan;
589 trace_usb_dwc2_work_bh_next(chan);
590 }
591 } while (chan != s->next_chan);
592
593 if (found) {
594 expire_time = t_now + NANOSECONDS_PER_SECOND / 4000;
595 timer_mod(s->frame_timer, expire_time);
596 }
597 s->working = false;
598 }
599
600 static void dwc2_enable_chan(DWC2State *s, uint32_t index)
601 {
602 USBDevice *dev;
603 USBEndpoint *ep;
604 uint32_t hcchar;
605 uint32_t hctsiz;
606 uint32_t devadr, epnum, epdir, eptype, pid, len;
607 DWC2Packet *p;
608
609 assert((index >> 3) < DWC2_NB_CHAN);
610 p = &s->packet[index >> 3];
611 hcchar = s->hreg1[index];
612 hctsiz = s->hreg1[index + 4];
613 devadr = get_field(hcchar, HCCHAR_DEVADDR);
614 epnum = get_field(hcchar, HCCHAR_EPNUM);
615 epdir = get_bit(hcchar, HCCHAR_EPDIR);
616 eptype = get_field(hcchar, HCCHAR_EPTYPE);
617 pid = get_field(hctsiz, TSIZ_SC_MC_PID);
618 len = get_field(hctsiz, TSIZ_XFERSIZE);
619
620 dev = dwc2_find_device(s, devadr);
621
622 trace_usb_dwc2_enable_chan(index >> 3, dev, &p->packet, epnum);
623 if (dev == NULL) {
624 return;
625 }
626
627 if (eptype == USB_ENDPOINT_XFER_CONTROL && pid == TSIZ_SC_MC_PID_SETUP) {
628 pid = USB_TOKEN_SETUP;
629 } else {
630 pid = epdir ? USB_TOKEN_IN : USB_TOKEN_OUT;
631 }
632
633 ep = usb_ep_get(dev, pid, epnum);
634
635 /*
636 * Hack: Networking doesn't like us delivering large transfers, it kind
637 * of works but the latency is horrible. So if the transfer is <= the mtu
638 * size, we take that as a hint that this might be a network transfer,
639 * and do the transfer packet-by-packet.
640 */
641 if (len > 1536) {
642 p->small = false;
643 } else {
644 p->small = true;
645 }
646
647 dwc2_handle_packet(s, devadr, dev, ep, index, true);
648 qemu_bh_schedule(s->async_bh);
649 }
650
651 static const char *glbregnm[] = {
652 "GOTGCTL ", "GOTGINT ", "GAHBCFG ", "GUSBCFG ", "GRSTCTL ",
653 "GINTSTS ", "GINTMSK ", "GRXSTSR ", "GRXSTSP ", "GRXFSIZ ",
654 "GNPTXFSIZ", "GNPTXSTS ", "GI2CCTL ", "GPVNDCTL ", "GGPIO ",
655 "GUID ", "GSNPSID ", "GHWCFG1 ", "GHWCFG2 ", "GHWCFG3 ",
656 "GHWCFG4 ", "GLPMCFG ", "GPWRDN ", "GDFIFOCFG", "GADPCTL ",
657 "GREFCLK ", "GINTMSK2 ", "GINTSTS2 "
658 };
659
660 static uint64_t dwc2_glbreg_read(void *ptr, hwaddr addr, int index,
661 unsigned size)
662 {
663 DWC2State *s = ptr;
664 uint32_t val;
665
666 assert(addr <= GINTSTS2);
667 val = s->glbreg[index];
668
669 switch (addr) {
670 case GRSTCTL:
671 /* clear any self-clearing bits that were set */
672 val &= ~(GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH | GRSTCTL_IN_TKNQ_FLSH |
673 GRSTCTL_FRMCNTRRST | GRSTCTL_HSFTRST | GRSTCTL_CSFTRST);
674 s->glbreg[index] = val;
675 break;
676 default:
677 break;
678 }
679
680 trace_usb_dwc2_glbreg_read(addr, glbregnm[index], val);
681 return val;
682 }
683
684 static void dwc2_glbreg_write(void *ptr, hwaddr addr, int index, uint64_t val,
685 unsigned size)
686 {
687 DWC2State *s = ptr;
688 uint64_t orig = val;
689 uint32_t *mmio;
690 uint32_t old;
691 int iflg = 0;
692
693 assert(addr <= GINTSTS2);
694 mmio = &s->glbreg[index];
695 old = *mmio;
696
697 switch (addr) {
698 case GOTGCTL:
699 /* don't allow setting of read-only bits */
700 val &= ~(GOTGCTL_MULT_VALID_BC_MASK | GOTGCTL_BSESVLD |
701 GOTGCTL_ASESVLD | GOTGCTL_DBNC_SHORT | GOTGCTL_CONID_B |
702 GOTGCTL_HSTNEGSCS | GOTGCTL_SESREQSCS);
703 /* don't allow clearing of read-only bits */
704 val |= old & (GOTGCTL_MULT_VALID_BC_MASK | GOTGCTL_BSESVLD |
705 GOTGCTL_ASESVLD | GOTGCTL_DBNC_SHORT | GOTGCTL_CONID_B |
706 GOTGCTL_HSTNEGSCS | GOTGCTL_SESREQSCS);
707 break;
708 case GAHBCFG:
709 if ((val & GAHBCFG_GLBL_INTR_EN) && !(old & GAHBCFG_GLBL_INTR_EN)) {
710 iflg = 1;
711 }
712 break;
713 case GRSTCTL:
714 val |= GRSTCTL_AHBIDLE;
715 val &= ~GRSTCTL_DMAREQ;
716 if (!(old & GRSTCTL_TXFFLSH) && (val & GRSTCTL_TXFFLSH)) {
717 /* TODO - TX fifo flush */
718 qemu_log_mask(LOG_UNIMP, "Tx FIFO flush not implemented\n");
719 }
720 if (!(old & GRSTCTL_RXFFLSH) && (val & GRSTCTL_RXFFLSH)) {
721 /* TODO - RX fifo flush */
722 qemu_log_mask(LOG_UNIMP, "Rx FIFO flush not implemented\n");
723 }
724 if (!(old & GRSTCTL_IN_TKNQ_FLSH) && (val & GRSTCTL_IN_TKNQ_FLSH)) {
725 /* TODO - device IN token queue flush */
726 qemu_log_mask(LOG_UNIMP, "Token queue flush not implemented\n");
727 }
728 if (!(old & GRSTCTL_FRMCNTRRST) && (val & GRSTCTL_FRMCNTRRST)) {
729 /* TODO - host frame counter reset */
730 qemu_log_mask(LOG_UNIMP, "Frame counter reset not implemented\n");
731 }
732 if (!(old & GRSTCTL_HSFTRST) && (val & GRSTCTL_HSFTRST)) {
733 /* TODO - host soft reset */
734 qemu_log_mask(LOG_UNIMP, "Host soft reset not implemented\n");
735 }
736 if (!(old & GRSTCTL_CSFTRST) && (val & GRSTCTL_CSFTRST)) {
737 /* TODO - core soft reset */
738 qemu_log_mask(LOG_UNIMP, "Core soft reset not implemented\n");
739 }
740 /* don't allow clearing of self-clearing bits */
741 val |= old & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH |
742 GRSTCTL_IN_TKNQ_FLSH | GRSTCTL_FRMCNTRRST |
743 GRSTCTL_HSFTRST | GRSTCTL_CSFTRST);
744 break;
745 case GINTSTS:
746 /* clear the write-1-to-clear bits */
747 val |= ~old;
748 val = ~val;
749 /* don't allow clearing of read-only bits */
750 val |= old & (GINTSTS_PTXFEMP | GINTSTS_HCHINT | GINTSTS_PRTINT |
751 GINTSTS_OEPINT | GINTSTS_IEPINT | GINTSTS_GOUTNAKEFF |
752 GINTSTS_GINNAKEFF | GINTSTS_NPTXFEMP | GINTSTS_RXFLVL |
753 GINTSTS_OTGINT | GINTSTS_CURMODE_HOST);
754 iflg = 1;
755 break;
756 case GINTMSK:
757 iflg = 1;
758 break;
759 default:
760 break;
761 }
762
763 trace_usb_dwc2_glbreg_write(addr, glbregnm[index], orig, old, val);
764 *mmio = val;
765
766 if (iflg) {
767 dwc2_update_irq(s);
768 }
769 }
770
771 static uint64_t dwc2_fszreg_read(void *ptr, hwaddr addr, int index,
772 unsigned size)
773 {
774 DWC2State *s = ptr;
775 uint32_t val;
776
777 assert(addr == HPTXFSIZ);
778 val = s->fszreg[index];
779
780 trace_usb_dwc2_fszreg_read(addr, val);
781 return val;
782 }
783
784 static void dwc2_fszreg_write(void *ptr, hwaddr addr, int index, uint64_t val,
785 unsigned size)
786 {
787 DWC2State *s = ptr;
788 uint64_t orig = val;
789 uint32_t *mmio;
790 uint32_t old;
791
792 assert(addr == HPTXFSIZ);
793 mmio = &s->fszreg[index];
794 old = *mmio;
795
796 trace_usb_dwc2_fszreg_write(addr, orig, old, val);
797 *mmio = val;
798 }
799
800 static const char *hreg0nm[] = {
801 "HCFG ", "HFIR ", "HFNUM ", "<rsvd> ", "HPTXSTS ",
802 "HAINT ", "HAINTMSK ", "HFLBADDR ", "<rsvd> ", "<rsvd> ",
803 "<rsvd> ", "<rsvd> ", "<rsvd> ", "<rsvd> ", "<rsvd> ",
804 "<rsvd> ", "HPRT0 "
805 };
806
807 static uint64_t dwc2_hreg0_read(void *ptr, hwaddr addr, int index,
808 unsigned size)
809 {
810 DWC2State *s = ptr;
811 uint32_t val;
812
813 assert(addr >= HCFG && addr <= HPRT0);
814 val = s->hreg0[index];
815
816 switch (addr) {
817 case HFNUM:
818 val = (dwc2_get_frame_remaining(s) << HFNUM_FRREM_SHIFT) |
819 (s->hfnum << HFNUM_FRNUM_SHIFT);
820 break;
821 default:
822 break;
823 }
824
825 trace_usb_dwc2_hreg0_read(addr, hreg0nm[index], val);
826 return val;
827 }
828
829 static void dwc2_hreg0_write(void *ptr, hwaddr addr, int index, uint64_t val,
830 unsigned size)
831 {
832 DWC2State *s = ptr;
833 USBDevice *dev = s->uport.dev;
834 uint64_t orig = val;
835 uint32_t *mmio;
836 uint32_t tval, told, old;
837 int prst = 0;
838 int iflg = 0;
839
840 assert(addr >= HCFG && addr <= HPRT0);
841 mmio = &s->hreg0[index];
842 old = *mmio;
843
844 switch (addr) {
845 case HFIR:
846 break;
847 case HFNUM:
848 case HPTXSTS:
849 case HAINT:
850 qemu_log_mask(LOG_GUEST_ERROR, "%s: write to read-only register\n",
851 __func__);
852 return;
853 case HAINTMSK:
854 val &= 0xffff;
855 break;
856 case HPRT0:
857 /* don't allow clearing of read-only bits */
858 val |= old & (HPRT0_SPD_MASK | HPRT0_LNSTS_MASK | HPRT0_OVRCURRACT |
859 HPRT0_CONNSTS);
860 /* don't allow clearing of self-clearing bits */
861 val |= old & (HPRT0_SUSP | HPRT0_RES);
862 /* don't allow setting of self-setting bits */
863 if (!(old & HPRT0_ENA) && (val & HPRT0_ENA)) {
864 val &= ~HPRT0_ENA;
865 }
866 /* clear the write-1-to-clear bits */
867 tval = val & (HPRT0_OVRCURRCHG | HPRT0_ENACHG | HPRT0_ENA |
868 HPRT0_CONNDET);
869 told = old & (HPRT0_OVRCURRCHG | HPRT0_ENACHG | HPRT0_ENA |
870 HPRT0_CONNDET);
871 tval |= ~told;
872 tval = ~tval;
873 tval &= (HPRT0_OVRCURRCHG | HPRT0_ENACHG | HPRT0_ENA |
874 HPRT0_CONNDET);
875 val &= ~(HPRT0_OVRCURRCHG | HPRT0_ENACHG | HPRT0_ENA |
876 HPRT0_CONNDET);
877 val |= tval;
878 if (!(val & HPRT0_RST) && (old & HPRT0_RST)) {
879 if (dev && dev->attached) {
880 val |= HPRT0_ENA | HPRT0_ENACHG;
881 prst = 1;
882 }
883 }
884 if (val & (HPRT0_OVRCURRCHG | HPRT0_ENACHG | HPRT0_CONNDET)) {
885 iflg = 1;
886 } else {
887 iflg = -1;
888 }
889 break;
890 default:
891 break;
892 }
893
894 if (prst) {
895 trace_usb_dwc2_hreg0_write(addr, hreg0nm[index], orig, old,
896 val & ~HPRT0_CONNDET);
897 trace_usb_dwc2_hreg0_action("call usb_port_reset");
898 usb_port_reset(&s->uport);
899 val &= ~HPRT0_CONNDET;
900 } else {
901 trace_usb_dwc2_hreg0_write(addr, hreg0nm[index], orig, old, val);
902 }
903
904 *mmio = val;
905
906 if (iflg > 0) {
907 trace_usb_dwc2_hreg0_action("enable PRTINT");
908 dwc2_raise_global_irq(s, GINTSTS_PRTINT);
909 } else if (iflg < 0) {
910 trace_usb_dwc2_hreg0_action("disable PRTINT");
911 dwc2_lower_global_irq(s, GINTSTS_PRTINT);
912 }
913 }
914
915 static const char *hreg1nm[] = {
916 "HCCHAR ", "HCSPLT ", "HCINT ", "HCINTMSK", "HCTSIZ ", "HCDMA ",
917 "<rsvd> ", "HCDMAB "
918 };
919
920 static uint64_t dwc2_hreg1_read(void *ptr, hwaddr addr, int index,
921 unsigned size)
922 {
923 DWC2State *s = ptr;
924 uint32_t val;
925
926 assert(addr >= HCCHAR(0) && addr <= HCDMAB(DWC2_NB_CHAN - 1));
927 val = s->hreg1[index];
928
929 trace_usb_dwc2_hreg1_read(addr, hreg1nm[index & 7], addr >> 5, val);
930 return val;
931 }
932
933 static void dwc2_hreg1_write(void *ptr, hwaddr addr, int index, uint64_t val,
934 unsigned size)
935 {
936 DWC2State *s = ptr;
937 uint64_t orig = val;
938 uint32_t *mmio;
939 uint32_t old;
940 int iflg = 0;
941 int enflg = 0;
942 int disflg = 0;
943
944 assert(addr >= HCCHAR(0) && addr <= HCDMAB(DWC2_NB_CHAN - 1));
945 mmio = &s->hreg1[index];
946 old = *mmio;
947
948 switch (HSOTG_REG(0x500) + (addr & 0x1c)) {
949 case HCCHAR(0):
950 if ((val & HCCHAR_CHDIS) && !(old & HCCHAR_CHDIS)) {
951 val &= ~(HCCHAR_CHENA | HCCHAR_CHDIS);
952 disflg = 1;
953 } else {
954 val |= old & HCCHAR_CHDIS;
955 if ((val & HCCHAR_CHENA) && !(old & HCCHAR_CHENA)) {
956 val &= ~HCCHAR_CHDIS;
957 enflg = 1;
958 } else {
959 val |= old & HCCHAR_CHENA;
960 }
961 }
962 break;
963 case HCINT(0):
964 /* clear the write-1-to-clear bits */
965 val |= ~old;
966 val = ~val;
967 val &= ~HCINTMSK_RESERVED14_31;
968 iflg = 1;
969 break;
970 case HCINTMSK(0):
971 val &= ~HCINTMSK_RESERVED14_31;
972 iflg = 1;
973 break;
974 case HCDMAB(0):
975 qemu_log_mask(LOG_GUEST_ERROR, "%s: write to read-only register\n",
976 __func__);
977 return;
978 default:
979 break;
980 }
981
982 trace_usb_dwc2_hreg1_write(addr, hreg1nm[index & 7], index >> 3, orig,
983 old, val);
984 *mmio = val;
985
986 if (disflg) {
987 /* set ChHltd in HCINT */
988 s->hreg1[(index & ~7) + 2] |= HCINTMSK_CHHLTD;
989 iflg = 1;
990 }
991
992 if (enflg) {
993 dwc2_enable_chan(s, index & ~7);
994 }
995
996 if (iflg) {
997 dwc2_update_hc_irq(s, index & ~7);
998 }
999 }
1000
1001 static const char *pcgregnm[] = {
1002 "PCGCTL ", "PCGCCTL1 "
1003 };
1004
1005 static uint64_t dwc2_pcgreg_read(void *ptr, hwaddr addr, int index,
1006 unsigned size)
1007 {
1008 DWC2State *s = ptr;
1009 uint32_t val;
1010
1011 assert(addr >= PCGCTL && addr <= PCGCCTL1);
1012 val = s->pcgreg[index];
1013
1014 trace_usb_dwc2_pcgreg_read(addr, pcgregnm[index], val);
1015 return val;
1016 }
1017
1018 static void dwc2_pcgreg_write(void *ptr, hwaddr addr, int index,
1019 uint64_t val, unsigned size)
1020 {
1021 DWC2State *s = ptr;
1022 uint64_t orig = val;
1023 uint32_t *mmio;
1024 uint32_t old;
1025
1026 assert(addr >= PCGCTL && addr <= PCGCCTL1);
1027 mmio = &s->pcgreg[index];
1028 old = *mmio;
1029
1030 trace_usb_dwc2_pcgreg_write(addr, pcgregnm[index], orig, old, val);
1031 *mmio = val;
1032 }
1033
1034 static uint64_t dwc2_hsotg_read(void *ptr, hwaddr addr, unsigned size)
1035 {
1036 uint64_t val;
1037
1038 switch (addr) {
1039 case HSOTG_REG(0x000) ... HSOTG_REG(0x0fc):
1040 val = dwc2_glbreg_read(ptr, addr, (addr - HSOTG_REG(0x000)) >> 2, size);
1041 break;
1042 case HSOTG_REG(0x100):
1043 val = dwc2_fszreg_read(ptr, addr, (addr - HSOTG_REG(0x100)) >> 2, size);
1044 break;
1045 case HSOTG_REG(0x104) ... HSOTG_REG(0x3fc):
1046 /* Gadget-mode registers, just return 0 for now */
1047 val = 0;
1048 break;
1049 case HSOTG_REG(0x400) ... HSOTG_REG(0x4fc):
1050 val = dwc2_hreg0_read(ptr, addr, (addr - HSOTG_REG(0x400)) >> 2, size);
1051 break;
1052 case HSOTG_REG(0x500) ... HSOTG_REG(0x7fc):
1053 val = dwc2_hreg1_read(ptr, addr, (addr - HSOTG_REG(0x500)) >> 2, size);
1054 break;
1055 case HSOTG_REG(0x800) ... HSOTG_REG(0xdfc):
1056 /* Gadget-mode registers, just return 0 for now */
1057 val = 0;
1058 break;
1059 case HSOTG_REG(0xe00) ... HSOTG_REG(0xffc):
1060 val = dwc2_pcgreg_read(ptr, addr, (addr - HSOTG_REG(0xe00)) >> 2, size);
1061 break;
1062 default:
1063 g_assert_not_reached();
1064 }
1065
1066 return val;
1067 }
1068
1069 static void dwc2_hsotg_write(void *ptr, hwaddr addr, uint64_t val,
1070 unsigned size)
1071 {
1072 switch (addr) {
1073 case HSOTG_REG(0x000) ... HSOTG_REG(0x0fc):
1074 dwc2_glbreg_write(ptr, addr, (addr - HSOTG_REG(0x000)) >> 2, val, size);
1075 break;
1076 case HSOTG_REG(0x100):
1077 dwc2_fszreg_write(ptr, addr, (addr - HSOTG_REG(0x100)) >> 2, val, size);
1078 break;
1079 case HSOTG_REG(0x104) ... HSOTG_REG(0x3fc):
1080 /* Gadget-mode registers, do nothing for now */
1081 break;
1082 case HSOTG_REG(0x400) ... HSOTG_REG(0x4fc):
1083 dwc2_hreg0_write(ptr, addr, (addr - HSOTG_REG(0x400)) >> 2, val, size);
1084 break;
1085 case HSOTG_REG(0x500) ... HSOTG_REG(0x7fc):
1086 dwc2_hreg1_write(ptr, addr, (addr - HSOTG_REG(0x500)) >> 2, val, size);
1087 break;
1088 case HSOTG_REG(0x800) ... HSOTG_REG(0xdfc):
1089 /* Gadget-mode registers, do nothing for now */
1090 break;
1091 case HSOTG_REG(0xe00) ... HSOTG_REG(0xffc):
1092 dwc2_pcgreg_write(ptr, addr, (addr - HSOTG_REG(0xe00)) >> 2, val, size);
1093 break;
1094 default:
1095 g_assert_not_reached();
1096 }
1097 }
1098
1099 static const MemoryRegionOps dwc2_mmio_hsotg_ops = {
1100 .read = dwc2_hsotg_read,
1101 .write = dwc2_hsotg_write,
1102 .impl.min_access_size = 4,
1103 .impl.max_access_size = 4,
1104 .endianness = DEVICE_LITTLE_ENDIAN,
1105 };
1106
1107 static uint64_t dwc2_hreg2_read(void *ptr, hwaddr addr, unsigned size)
1108 {
1109 /* TODO - implement FIFOs to support slave mode */
1110 trace_usb_dwc2_hreg2_read(addr, addr >> 12, 0);
1111 qemu_log_mask(LOG_UNIMP, "FIFO read not implemented\n");
1112 return 0;
1113 }
1114
1115 static void dwc2_hreg2_write(void *ptr, hwaddr addr, uint64_t val,
1116 unsigned size)
1117 {
1118 uint64_t orig = val;
1119
1120 /* TODO - implement FIFOs to support slave mode */
1121 trace_usb_dwc2_hreg2_write(addr, addr >> 12, orig, 0, val);
1122 qemu_log_mask(LOG_UNIMP, "FIFO write not implemented\n");
1123 }
1124
1125 static const MemoryRegionOps dwc2_mmio_hreg2_ops = {
1126 .read = dwc2_hreg2_read,
1127 .write = dwc2_hreg2_write,
1128 .impl.min_access_size = 4,
1129 .impl.max_access_size = 4,
1130 .endianness = DEVICE_LITTLE_ENDIAN,
1131 };
1132
1133 static void dwc2_wakeup_endpoint(USBBus *bus, USBEndpoint *ep,
1134 unsigned int stream)
1135 {
1136 DWC2State *s = container_of(bus, DWC2State, bus);
1137
1138 trace_usb_dwc2_wakeup_endpoint(ep, stream);
1139
1140 /* TODO - do something here? */
1141 qemu_bh_schedule(s->async_bh);
1142 }
1143
1144 static USBBusOps dwc2_bus_ops = {
1145 .wakeup_endpoint = dwc2_wakeup_endpoint,
1146 };
1147
1148 static void dwc2_work_timer(void *opaque)
1149 {
1150 DWC2State *s = opaque;
1151
1152 trace_usb_dwc2_work_timer();
1153 qemu_bh_schedule(s->async_bh);
1154 }
1155
1156 static void dwc2_reset_enter(Object *obj, ResetType type)
1157 {
1158 DWC2Class *c = DWC2_GET_CLASS(obj);
1159 DWC2State *s = DWC2_USB(obj);
1160 int i;
1161
1162 trace_usb_dwc2_reset_enter();
1163
1164 if (c->parent_phases.enter) {
1165 c->parent_phases.enter(obj, type);
1166 }
1167
1168 timer_del(s->frame_timer);
1169 qemu_bh_cancel(s->async_bh);
1170
1171 if (s->uport.dev && s->uport.dev->attached) {
1172 usb_detach(&s->uport);
1173 }
1174
1175 dwc2_bus_stop(s);
1176
1177 s->gotgctl = GOTGCTL_BSESVLD | GOTGCTL_ASESVLD | GOTGCTL_CONID_B;
1178 s->gotgint = 0;
1179 s->gahbcfg = 0;
1180 s->gusbcfg = 5 << GUSBCFG_USBTRDTIM_SHIFT;
1181 s->grstctl = GRSTCTL_AHBIDLE;
1182 s->gintsts = GINTSTS_CONIDSTSCHNG | GINTSTS_PTXFEMP | GINTSTS_NPTXFEMP |
1183 GINTSTS_CURMODE_HOST;
1184 s->gintmsk = 0;
1185 s->grxstsr = 0;
1186 s->grxstsp = 0;
1187 s->grxfsiz = 1024;
1188 s->gnptxfsiz = 1024 << FIFOSIZE_DEPTH_SHIFT;
1189 s->gnptxsts = (4 << FIFOSIZE_DEPTH_SHIFT) | 1024;
1190 s->gi2cctl = GI2CCTL_I2CDATSE0 | GI2CCTL_ACK;
1191 s->gpvndctl = 0;
1192 s->ggpio = 0;
1193 s->guid = 0;
1194 s->gsnpsid = 0x4f54294a;
1195 s->ghwcfg1 = 0;
1196 s->ghwcfg2 = (8 << GHWCFG2_DEV_TOKEN_Q_DEPTH_SHIFT) |
1197 (4 << GHWCFG2_HOST_PERIO_TX_Q_DEPTH_SHIFT) |
1198 (4 << GHWCFG2_NONPERIO_TX_Q_DEPTH_SHIFT) |
1199 GHWCFG2_DYNAMIC_FIFO |
1200 GHWCFG2_PERIO_EP_SUPPORTED |
1201 ((DWC2_NB_CHAN - 1) << GHWCFG2_NUM_HOST_CHAN_SHIFT) |
1202 (GHWCFG2_INT_DMA_ARCH << GHWCFG2_ARCHITECTURE_SHIFT) |
1203 (GHWCFG2_OP_MODE_NO_SRP_CAPABLE_HOST << GHWCFG2_OP_MODE_SHIFT);
1204 s->ghwcfg3 = (4096 << GHWCFG3_DFIFO_DEPTH_SHIFT) |
1205 (4 << GHWCFG3_PACKET_SIZE_CNTR_WIDTH_SHIFT) |
1206 (4 << GHWCFG3_XFER_SIZE_CNTR_WIDTH_SHIFT);
1207 s->ghwcfg4 = 0;
1208 s->glpmcfg = 0;
1209 s->gpwrdn = GPWRDN_PWRDNRSTN;
1210 s->gdfifocfg = 0;
1211 s->gadpctl = 0;
1212 s->grefclk = 0;
1213 s->gintmsk2 = 0;
1214 s->gintsts2 = 0;
1215
1216 s->hptxfsiz = 500 << FIFOSIZE_DEPTH_SHIFT;
1217
1218 s->hcfg = 2 << HCFG_RESVALID_SHIFT;
1219 s->hfir = 60000;
1220 s->hfnum = 0x3fff;
1221 s->hptxsts = (16 << TXSTS_QSPCAVAIL_SHIFT) | 32768;
1222 s->haint = 0;
1223 s->haintmsk = 0;
1224 s->hprt0 = 0;
1225
1226 memset(s->hreg1, 0, sizeof(s->hreg1));
1227 memset(s->pcgreg, 0, sizeof(s->pcgreg));
1228
1229 s->sof_time = 0;
1230 s->frame_number = 0;
1231 s->fi = USB_FRMINTVL - 1;
1232 s->next_chan = 0;
1233 s->working = false;
1234
1235 for (i = 0; i < DWC2_NB_CHAN; i++) {
1236 s->packet[i].needs_service = false;
1237 }
1238 }
1239
1240 static void dwc2_reset_hold(Object *obj)
1241 {
1242 DWC2Class *c = DWC2_GET_CLASS(obj);
1243 DWC2State *s = DWC2_USB(obj);
1244
1245 trace_usb_dwc2_reset_hold();
1246
1247 if (c->parent_phases.hold) {
1248 c->parent_phases.hold(obj);
1249 }
1250
1251 dwc2_update_irq(s);
1252 }
1253
1254 static void dwc2_reset_exit(Object *obj)
1255 {
1256 DWC2Class *c = DWC2_GET_CLASS(obj);
1257 DWC2State *s = DWC2_USB(obj);
1258
1259 trace_usb_dwc2_reset_exit();
1260
1261 if (c->parent_phases.exit) {
1262 c->parent_phases.exit(obj);
1263 }
1264
1265 s->hprt0 = HPRT0_PWR;
1266 if (s->uport.dev && s->uport.dev->attached) {
1267 usb_attach(&s->uport);
1268 usb_device_reset(s->uport.dev);
1269 }
1270 }
1271
1272 static void dwc2_realize(DeviceState *dev, Error **errp)
1273 {
1274 SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
1275 DWC2State *s = DWC2_USB(dev);
1276 Object *obj;
1277
1278 obj = object_property_get_link(OBJECT(dev), "dma-mr", &error_abort);
1279
1280 s->dma_mr = MEMORY_REGION(obj);
1281 address_space_init(&s->dma_as, s->dma_mr, "dwc2");
1282
1283 usb_bus_new(&s->bus, sizeof(s->bus), &dwc2_bus_ops, dev);
1284 usb_register_port(&s->bus, &s->uport, s, 0, &dwc2_port_ops,
1285 USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL |
1286 (s->usb_version == 2 ? USB_SPEED_MASK_HIGH : 0));
1287 s->uport.dev = 0;
1288
1289 s->usb_frame_time = NANOSECONDS_PER_SECOND / 1000; /* 1000000 */
1290 if (NANOSECONDS_PER_SECOND >= USB_HZ_FS) {
1291 s->usb_bit_time = NANOSECONDS_PER_SECOND / USB_HZ_FS; /* 83.3 */
1292 } else {
1293 s->usb_bit_time = 1;
1294 }
1295
1296 s->fi = USB_FRMINTVL - 1;
1297 s->eof_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, dwc2_frame_boundary, s);
1298 s->frame_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, dwc2_work_timer, s);
1299 s->async_bh = qemu_bh_new(dwc2_work_bh, s);
1300
1301 sysbus_init_irq(sbd, &s->irq);
1302 }
1303
1304 static void dwc2_init(Object *obj)
1305 {
1306 SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
1307 DWC2State *s = DWC2_USB(obj);
1308
1309 memory_region_init(&s->container, obj, "dwc2", DWC2_MMIO_SIZE);
1310 sysbus_init_mmio(sbd, &s->container);
1311
1312 memory_region_init_io(&s->hsotg, obj, &dwc2_mmio_hsotg_ops, s,
1313 "dwc2-io", 4 * KiB);
1314 memory_region_add_subregion(&s->container, 0x0000, &s->hsotg);
1315
1316 memory_region_init_io(&s->fifos, obj, &dwc2_mmio_hreg2_ops, s,
1317 "dwc2-fifo", 64 * KiB);
1318 memory_region_add_subregion(&s->container, 0x1000, &s->fifos);
1319 }
1320
1321 static const VMStateDescription vmstate_dwc2_state_packet = {
1322 .name = "dwc2/packet",
1323 .version_id = 1,
1324 .minimum_version_id = 1,
1325 .fields = (VMStateField[]) {
1326 VMSTATE_UINT32(devadr, DWC2Packet),
1327 VMSTATE_UINT32(epnum, DWC2Packet),
1328 VMSTATE_UINT32(epdir, DWC2Packet),
1329 VMSTATE_UINT32(mps, DWC2Packet),
1330 VMSTATE_UINT32(pid, DWC2Packet),
1331 VMSTATE_UINT32(index, DWC2Packet),
1332 VMSTATE_UINT32(pcnt, DWC2Packet),
1333 VMSTATE_UINT32(len, DWC2Packet),
1334 VMSTATE_INT32(async, DWC2Packet),
1335 VMSTATE_BOOL(small, DWC2Packet),
1336 VMSTATE_BOOL(needs_service, DWC2Packet),
1337 VMSTATE_END_OF_LIST()
1338 },
1339 };
1340
1341 const VMStateDescription vmstate_dwc2_state = {
1342 .name = "dwc2",
1343 .version_id = 1,
1344 .minimum_version_id = 1,
1345 .fields = (VMStateField[]) {
1346 VMSTATE_UINT32_ARRAY(glbreg, DWC2State,
1347 DWC2_GLBREG_SIZE / sizeof(uint32_t)),
1348 VMSTATE_UINT32_ARRAY(fszreg, DWC2State,
1349 DWC2_FSZREG_SIZE / sizeof(uint32_t)),
1350 VMSTATE_UINT32_ARRAY(hreg0, DWC2State,
1351 DWC2_HREG0_SIZE / sizeof(uint32_t)),
1352 VMSTATE_UINT32_ARRAY(hreg1, DWC2State,
1353 DWC2_HREG1_SIZE / sizeof(uint32_t)),
1354 VMSTATE_UINT32_ARRAY(pcgreg, DWC2State,
1355 DWC2_PCGREG_SIZE / sizeof(uint32_t)),
1356
1357 VMSTATE_TIMER_PTR(eof_timer, DWC2State),
1358 VMSTATE_TIMER_PTR(frame_timer, DWC2State),
1359 VMSTATE_INT64(sof_time, DWC2State),
1360 VMSTATE_INT64(usb_frame_time, DWC2State),
1361 VMSTATE_INT64(usb_bit_time, DWC2State),
1362 VMSTATE_UINT32(usb_version, DWC2State),
1363 VMSTATE_UINT16(frame_number, DWC2State),
1364 VMSTATE_UINT16(fi, DWC2State),
1365 VMSTATE_UINT16(next_chan, DWC2State),
1366 VMSTATE_BOOL(working, DWC2State),
1367
1368 VMSTATE_STRUCT_ARRAY(packet, DWC2State, DWC2_NB_CHAN, 1,
1369 vmstate_dwc2_state_packet, DWC2Packet),
1370 VMSTATE_UINT8_2DARRAY(usb_buf, DWC2State, DWC2_NB_CHAN,
1371 DWC2_MAX_XFER_SIZE),
1372
1373 VMSTATE_END_OF_LIST()
1374 }
1375 };
1376
1377 static Property dwc2_usb_properties[] = {
1378 DEFINE_PROP_UINT32("usb_version", DWC2State, usb_version, 2),
1379 DEFINE_PROP_END_OF_LIST(),
1380 };
1381
1382 static void dwc2_class_init(ObjectClass *klass, void *data)
1383 {
1384 DeviceClass *dc = DEVICE_CLASS(klass);
1385 DWC2Class *c = DWC2_CLASS(klass);
1386 ResettableClass *rc = RESETTABLE_CLASS(klass);
1387
1388 dc->realize = dwc2_realize;
1389 dc->vmsd = &vmstate_dwc2_state;
1390 set_bit(DEVICE_CATEGORY_USB, dc->categories);
1391 device_class_set_props(dc, dwc2_usb_properties);
1392 resettable_class_set_parent_phases(rc, dwc2_reset_enter, dwc2_reset_hold,
1393 dwc2_reset_exit, &c->parent_phases);
1394 }
1395
1396 static const TypeInfo dwc2_usb_type_info = {
1397 .name = TYPE_DWC2_USB,
1398 .parent = TYPE_SYS_BUS_DEVICE,
1399 .instance_size = sizeof(DWC2State),
1400 .instance_init = dwc2_init,
1401 .class_size = sizeof(DWC2Class),
1402 .class_init = dwc2_class_init,
1403 };
1404
1405 static void dwc2_usb_register_types(void)
1406 {
1407 type_register_static(&dwc2_usb_type_info);
1408 }
1409
1410 type_init(dwc2_usb_register_types)