libxr  1.0
Want to be the best embedded framework
Loading...
Searching...
No Matches
esp_usb_ep.cpp
1#include "esp_usb_ep.hpp"
2
3#if SOC_USB_OTG_SUPPORTED && defined(CONFIG_IDF_TARGET_ESP32S3) && \
4 CONFIG_IDF_TARGET_ESP32S3
5
6#include <algorithm>
7#include <cstring>
8
9#include "esp_heap_caps.h"
10#include "esp_usb.hpp"
11#include "esp_usb_dev.hpp"
12
13namespace LibXR
14{
15
16ESP32USBEndpoint::ESP32USBEndpoint(ESP32USBDevice& device, EPNumber number,
17 Direction direction, RawData buffer)
18 : USB::Endpoint(number, direction, buffer), device_(device)
19{
20}
21
22void ESP32USBEndpoint::Configure(const Config& cfg)
23{
24 ASSERT(cfg.direction == Direction::IN || cfg.direction == Direction::OUT);
25
26 auto& ep_cfg = GetConfig();
27 ep_cfg = cfg;
28 ep_cfg.max_packet_size = ESPUSBDetail::ClampPacketSize(cfg.type, cfg.max_packet_size);
29 if (ep_cfg.max_packet_size == 0U)
30 {
31 ep_cfg.max_packet_size = (cfg.type == Type::ISOCHRONOUS) ? 1023U : 64U;
32 }
33
34 auto buffer = GetBuffer();
35 if (buffer.size_ < ep_cfg.max_packet_size)
36 {
37 ep_cfg.max_packet_size = static_cast<uint16_t>(buffer.size_);
38 }
39
40 ASSERT(ep_cfg.max_packet_size > 0U);
41
42 if (device_.DmaEnabled() && (buffer.size_ > 0U) && !EnsureDmaShadow(buffer.size_))
43 {
44 SetState(State::ERROR);
45 return;
46 }
47
48 if (cfg.direction == Direction::IN)
49 {
50 const bool is_bulk = (cfg.type == Type::BULK);
51 if (!fifo_allocated_ &&
52 !device_.AllocateTxFifo(EPNumberToInt8(GetNumber()), ep_cfg.max_packet_size,
53 is_bulk, fifo_words_))
54 {
55 SetState(State::ERROR);
56 return;
57 }
58 fifo_allocated_ = true;
59 }
60 else
61 {
62 if (!device_.EnsureRxFifo(ep_cfg.max_packet_size))
63 {
64 SetState(State::ERROR);
65 return;
66 }
67 }
68
69 ActivateHardwareEndpoint();
70 ResetTransferState();
71 SetState(State::IDLE);
72}
73
74void ESP32USBEndpoint::Close()
75{
76 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
77 const uint8_t ep_num = EPNumberToInt8(GetNumber());
78
79 if (GetDirection() == Direction::IN)
80 {
81 if (ep_num == 0U)
82 {
83 if (dev->diepctl0_reg.epena)
84 {
85 ESPUSBDetail::DisableInEndpointAndWait(dev);
86 }
87 }
88 else
89 {
90 dev->diepempmsk_reg.val &= ~(1UL << ep_num);
91 if (dev->in_eps[ep_num - 1U].diepctl_reg.epena)
92 {
93 ESPUSBDetail::DisableInEndpointAndWait(dev, ep_num);
94 }
95 }
96 dev->daintmsk_reg.val &= ~(1UL << ep_num);
97 }
98 else
99 {
100 if (ep_num == 0U)
101 {
102 ESPUSBDetail::DisableOutEndpointAndWait(dev->doepctl0_reg);
103 }
104 else
105 {
106 ESPUSBDetail::DisableOutEndpointAndWait(dev->out_eps[ep_num - 1U].doepctl_reg);
107 }
108 dev->daintmsk_reg.val &= ~(1UL << (16U + ep_num));
109 }
110
111 ResetTransferState();
112 SetState(State::DISABLED);
113}
114
115ErrorCode ESP32USBEndpoint::Stall()
116{
117 const bool is_in = (GetDirection() == Direction::IN);
118 if ((GetState() == State::BUSY) && is_in)
119 {
120 return ErrorCode::BUSY;
121 }
122
123 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
124 const uint8_t ep_num = EPNumberToInt8(GetNumber());
125
126 if (is_in)
127 {
128 if (ep_num == 0U)
129 {
130 dev->diepctl0_reg.stall = 1;
131 }
132 else
133 {
134 dev->in_eps[ep_num - 1U].diepctl_reg.stall = 1;
135 }
136 }
137 else
138 {
139 if (ep_num == 0U)
140 {
141 dev->doepctl0_reg.stall = 1;
142 }
143 else
144 {
145 dev->out_eps[ep_num - 1U].doepctl_reg.stall = 1;
146 }
147 }
148
149 SetState(State::STALLED);
150 return ErrorCode::OK;
151}
152
153ErrorCode ESP32USBEndpoint::ClearStall()
154{
155 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
156 const uint8_t ep_num = EPNumberToInt8(GetNumber());
157
158 if (GetDirection() == Direction::IN)
159 {
160 if (ep_num == 0U)
161 {
162 dev->diepctl0_reg.stall = 0;
163 }
164 else
165 {
166 auto& reg = dev->in_eps[ep_num - 1U].diepctl_reg;
167 reg.stall = 0;
168 reg.setd0pid = 1;
169 }
170 }
171 else
172 {
173 if (ep_num == 0U)
174 {
175 dev->doepctl0_reg.stall = 0;
176 }
177 else
178 {
179 auto& reg = dev->out_eps[ep_num - 1U].doepctl_reg;
180 reg.stall = 0;
181 reg.setd0pid = 1;
182 }
183 }
184
185 SetState(State::IDLE);
186 return ErrorCode::OK;
187}
188
189ErrorCode ESP32USBEndpoint::Transfer(size_t size)
190{
191 if (GetState() == State::BUSY)
192 {
193 return ErrorCode::BUSY;
194 }
195
196 auto buffer = GetBuffer();
197 if (buffer.size_ < size)
198 {
199 return ErrorCode::NO_BUFF;
200 }
201
202 transfer_buffer_ = static_cast<uint8_t*>(buffer.addr_);
203 transfer_request_size_ = size;
204 transfer_actual_size_ = 0U;
205 transfer_queued_size_ = 0U;
206
207 const uint8_t ep_num = EPNumberToInt8(GetNumber());
208 if ((ep_num == 0U) && (GetDirection() == Direction::OUT))
209 {
210 ep0_out_phase_ = (size == 0U) ? Ep0OutPhase::STATUS : Ep0OutPhase::DATA;
211 }
212
213 if (UseDoubleBuffer() && GetDirection() == Direction::IN && size > 0U)
214 {
215 SwitchBuffer();
216 }
217
218 if (!PrepareTransferBuffer(size))
219 {
220 ResetTransferState();
221 return ErrorCode::NO_MEM;
222 }
223
224 SetState(State::BUSY);
225 ProgramTransfer(size);
226 return ErrorCode::OK;
227}
228
229size_t ESP32USBEndpoint::MaxTransferSize() const
230{
231 if (GetNumber() == EPNumber::EP0)
232 {
233 return MaxPacketSize();
234 }
235 return GetBuffer().size_;
236}
237
238void ESP32USBEndpoint::ResetHardwareState()
239{
240 fifo_allocated_ = false;
241 fifo_words_ = 0U;
242 ResetTransferState();
243 SetState(State::DISABLED);
244}
245
246void ESP32USBEndpoint::HandleInInterrupt(bool in_isr)
247{
248 const uint8_t ep_num = EPNumberToInt8(GetNumber());
249 usb_dwc_diepint_reg_t intr = {};
250 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
251
252 if (ep_num == 0U)
253 {
254 intr.val = dev->diepint0_reg.val;
255 dev->diepint0_reg.val = intr.val;
256 }
257 else
258 {
259 intr.val = dev->in_eps[ep_num - 1U].diepint_reg.val;
260 dev->in_eps[ep_num - 1U].diepint_reg.val = intr.val;
261 }
262
263 if (!device_.DmaEnabled() && intr.txfemp)
264 {
265 WriteMoreTxData();
266 if (transfer_queued_size_ >= transfer_request_size_)
267 {
268 dev->diepempmsk_reg.val &= ~(1UL << ep_num);
269 }
270 }
271
272 if (intr.xfercompl)
273 {
274 const bool rearm_ep0_setup = (ep_num == 0U) && device_.DmaEnabled() &&
275 (transfer_request_size_ == 0U) &&
276 device_.LastSetupDirectionOut();
277 dev->diepempmsk_reg.val &= ~(1UL << ep_num);
278 const size_t actual =
279 device_.DmaEnabled() ? GetCompletedTransferSize() : transfer_request_size_;
280 OnTransferCompleteCallback(in_isr, actual);
281 if (rearm_ep0_setup)
282 {
283 device_.ReloadSetupPacketCount();
284 }
285 if (GetState() != State::BUSY)
286 {
287 ResetTransferState();
288 }
289 }
290}
291
292void ESP32USBEndpoint::FinishPendingEp0InStatus(bool in_isr)
293{
294 if (!device_.DmaEnabled() || (device_.endpoint_map_.in[0] == nullptr))
295 {
296 return;
297 }
298
299 auto* ep0_in = static_cast<ESP32USBEndpoint*>(device_.endpoint_map_.in[0]);
300 if ((ep0_in->GetState() != State::BUSY) || (ep0_in->transfer_request_size_ != 0U))
301 {
302 return;
303 }
304
305 ep0_in->OnTransferCompleteCallback(in_isr, 0U);
306 if (ep0_in->GetState() != State::BUSY)
307 {
308 ep0_in->ResetTransferState();
309 }
310}
311
312void ESP32USBEndpoint::HandleOutInterrupt(bool in_isr)
313{
314 const uint8_t ep_num = EPNumberToInt8(GetNumber());
315 usb_dwc_doepint_reg_t intr = {};
316 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
317
318 if (ep_num == 0U)
319 {
320 intr.val = dev->doepint0_reg.val;
321 dev->doepint0_reg.val = intr.val;
322 }
323 else
324 {
325 intr.val = dev->out_eps[ep_num - 1U].doepint_reg.val;
326 dev->out_eps[ep_num - 1U].doepint_reg.val = intr.val;
327 }
328
329 const bool ep0_setup_related =
330 (ep_num == 0U) && (intr.setup || intr.stuppktrcvd || intr.back2backsetup);
331 const bool has_active_ep0_transfer =
332 (ep_num == 0U) && (GetState() == State::BUSY) &&
333 ((transfer_buffer_ != nullptr) || (transfer_request_size_ > 0U));
334
335 if (intr.xfercompl &&
336 ((ep_num != 0U) || ((ep0_out_phase_ != Ep0OutPhase::SETUP) && !ep0_setup_related &&
337 has_active_ep0_transfer)))
338 {
339 const size_t actual =
340 device_.DmaEnabled() ? GetCompletedTransferSize() : transfer_actual_size_;
341 ASSERT(FinishOutTransfer(actual));
342 if (ep_num == 0U)
343 {
344 FinishPendingEp0InStatus(in_isr);
345 }
346 OnTransferCompleteCallback(in_isr, actual);
347 if ((ep_num == 0U) && device_.DmaEnabled() && (transfer_request_size_ == 0U))
348 {
349 device_.ReloadSetupPacketCount();
350 }
351 if (GetState() != State::BUSY)
352 {
353 ResetTransferState();
354 }
355 }
356
357 if (intr.setup)
358 {
359 if (device_.DmaEnabled())
360 {
361 ASSERT(ESPUSBDetail::CacheSyncDmaBuffer(
362 device_.setup_packet_, ESP32USBDevice::SETUP_DMA_BUFFER_BYTES, false));
363 }
364 device_.UpdateSetupState(device_.setup_packet_);
365 const auto* setup = reinterpret_cast<const USB::SetupPacket*>(device_.setup_packet_);
366 const bool expect_out_data_stage =
367 ((setup->bmRequestType & 0x80U) == 0U) && (setup->wLength > 0U);
368
369 FinishPendingEp0InStatus(in_isr);
370 ep0_out_phase_ = Ep0OutPhase::SETUP;
371 ResetTransferState();
372 SetState(State::IDLE);
373
374 if (device_.endpoint_map_.in[0] != nullptr)
375 {
376 auto* ep0_in = static_cast<ESP32USBEndpoint*>(device_.endpoint_map_.in[0]);
377 if (ep0_in->GetState() == State::BUSY)
378 {
379 ep0_in->ResetTransferState();
380 ep0_in->SetState(State::IDLE);
381 }
382 }
383
384 if (device_.DmaEnabled() && !expect_out_data_stage)
385 {
386 device_.ReloadSetupPacketCount();
387 }
388 device_.OnSetupPacket(in_isr, setup);
389 }
390}
391
392void ESP32USBEndpoint::HandleRxData(size_t size)
393{
394 uint8_t* const dst = (transfer_buffer_ != nullptr)
395 ? (transfer_buffer_ + transfer_actual_size_)
396 : nullptr;
397 const size_t remain = (transfer_request_size_ > transfer_actual_size_)
398 ? (transfer_request_size_ - transfer_actual_size_)
399 : 0U;
400 const size_t copy_size = std::min(size, remain);
401 const size_t drop_size = size - copy_size;
402
403 if (copy_size > 0U)
404 {
405 ESPUSBDetail::ReadFifoPacket(
406 ESPUSBDetail::GetEndpointFifo(
407 reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE), 0),
408 dst, copy_size);
409 transfer_actual_size_ += copy_size;
410 }
411
412 if (drop_size == 0U)
413 {
414 return;
415 }
416
417 uint8_t sink[64] = {};
418 size_t remain_drop = drop_size;
419 auto* fifo = ESPUSBDetail::GetEndpointFifo(
420 reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE), 0);
421 while (remain_drop > 0U)
422 {
423 const size_t chunk = std::min(remain_drop, sizeof(sink));
424 ESPUSBDetail::ReadFifoPacket(fifo, sink, chunk);
425 remain_drop -= chunk;
426 }
427}
428
429void ESP32USBEndpoint::ObserveDmaRxStatus(uint8_t pktsts, size_t size)
430{
431 if (!device_.DmaEnabled() || (GetDirection() != Direction::OUT))
432 {
433 return;
434 }
435
436 if (pktsts != ESPUSBDetail::RX_STATUS_DATA)
437 {
438 return;
439 }
440
441 dma_rx_status_seen_ = true;
442 dma_rx_status_bytes_ = std::min(transfer_request_size_, dma_rx_status_bytes_ + size);
443}
444
445void ESP32USBEndpoint::ResetTransferState()
446{
447 transfer_buffer_ = nullptr;
448 transfer_hw_buffer_ = nullptr;
449 transfer_request_size_ = 0U;
450 transfer_actual_size_ = 0U;
451 transfer_queued_size_ = 0U;
452 transfer_uses_shadow_ = false;
453 transfer_direct_sync_size_ = 0U;
454 dma_rx_status_bytes_ = 0U;
455 dma_rx_status_seen_ = false;
456}
457
458bool ESP32USBEndpoint::EnsureDmaShadow(size_t size)
459{
460 const size_t need = ESPUSBDetail::AlignUp(size, ESPUSBDetail::USB_DMA_ALIGNMENT);
461 if (need == 0U)
462 {
463 return true;
464 }
465
466 if ((dma_shadow_buffer_ != nullptr) && (dma_shadow_size_ >= need))
467 {
468 return true;
469 }
470
471 void* new_buffer = heap_caps_aligned_alloc(ESPUSBDetail::USB_DMA_ALIGNMENT, need,
472 ESPUSBDetail::DMA_MEMORY_CAPS);
473 if (new_buffer == nullptr)
474 {
475 return false;
476 }
477
478 if (dma_shadow_buffer_ != nullptr)
479 {
480 heap_caps_free(dma_shadow_buffer_);
481 }
482
483 dma_shadow_buffer_ = static_cast<uint8_t*>(new_buffer);
484 dma_shadow_size_ = need;
485 return true;
486}
487
488bool ESP32USBEndpoint::PrepareTransferBuffer(size_t size)
489{
490 transfer_hw_buffer_ = transfer_buffer_;
491 transfer_uses_shadow_ = false;
492 transfer_direct_sync_size_ = 0U;
493
494 if (!device_.DmaEnabled() || (size == 0U))
495 {
496 return true;
497 }
498
499 if (GetDirection() == Direction::IN)
500 {
501 if (ESPUSBDetail::CanUseDirectInDmaBuffer(transfer_buffer_, size))
502 {
503 return ESPUSBDetail::CacheSyncDmaBuffer(transfer_hw_buffer_, size, true, true);
504 }
505 }
506 else
507 {
508 auto buffer = GetBuffer();
509 if (ESPUSBDetail::CanUseDirectOutDmaBuffer(buffer.addr_, buffer.size_))
510 {
511 transfer_direct_sync_size_ = buffer.size_;
512 return true;
513 }
514 }
515
516 if (!EnsureDmaShadow(size))
517 {
518 return false;
519 }
520
521 transfer_hw_buffer_ = dma_shadow_buffer_;
522 transfer_uses_shadow_ = true;
523
524 if (GetDirection() == Direction::IN)
525 {
526 ASSERT(transfer_buffer_ != nullptr);
527 std::memcpy(transfer_hw_buffer_, transfer_buffer_, size);
528 return ESPUSBDetail::CacheSyncDmaBuffer(
529 transfer_hw_buffer_, ESPUSBDetail::AlignUp(size, ESPUSBDetail::USB_DMA_ALIGNMENT),
530 true);
531 }
532
533 return ESPUSBDetail::CacheSyncDmaBuffer(
534 transfer_hw_buffer_, ESPUSBDetail::AlignUp(size, ESPUSBDetail::USB_DMA_ALIGNMENT),
535 false);
536}
537
538bool ESP32USBEndpoint::FinishOutTransfer(size_t actual_size)
539{
540 transfer_actual_size_ = actual_size;
541
542 if (!device_.DmaEnabled() || (actual_size == 0U))
543 {
544 return true;
545 }
546
547 ASSERT(transfer_hw_buffer_ != nullptr);
548
549 if (!transfer_uses_shadow_)
550 {
551 if (transfer_direct_sync_size_ == 0U)
552 {
553 return true;
554 }
555 return ESPUSBDetail::CacheSyncDmaBuffer(transfer_hw_buffer_,
556 transfer_direct_sync_size_, false);
557 }
558
559 ASSERT(transfer_buffer_ != nullptr);
560
561 if (!ESPUSBDetail::CacheSyncDmaBuffer(
562 transfer_hw_buffer_,
563 ESPUSBDetail::AlignUp(actual_size, ESPUSBDetail::USB_DMA_ALIGNMENT), false))
564 {
565 return false;
566 }
567
568 std::memcpy(transfer_buffer_, transfer_hw_buffer_, actual_size);
569 return true;
570}
571
572size_t ESP32USBEndpoint::GetRemainingTransferSize() const
573{
574 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
575 const uint8_t ep_num = EPNumberToInt8(GetNumber());
576
577 if (GetDirection() == Direction::IN)
578 {
579 if (ep_num == 0U)
580 {
581 return dev->dieptsiz0_reg.xfersize;
582 }
583 return dev->in_eps[ep_num - 1U].dieptsiz_reg.xfersize;
584 }
585
586 if (ep_num == 0U)
587 {
588 return dev->doeptsiz0_reg.xfersize;
589 }
590 return dev->out_eps[ep_num - 1U].doeptsiz_reg.xfersize;
591}
592
593size_t ESP32USBEndpoint::GetCompletedTransferSize() const
594{
595 if ((GetDirection() == Direction::OUT) && device_.DmaEnabled() && dma_rx_status_seen_)
596 {
597 return dma_rx_status_bytes_;
598 }
599
600 const size_t remaining = GetRemainingTransferSize();
601 return (remaining >= transfer_request_size_) ? 0U
602 : (transfer_request_size_ - remaining);
603}
604
605void ESP32USBEndpoint::ActivateHardwareEndpoint()
606{
607 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
608 const uint8_t ep_num = EPNumberToInt8(GetNumber());
609 auto& cfg = GetConfig();
610
611 if (GetDirection() == Direction::IN)
612 {
613 if (ep_num == 0U)
614 {
615 usb_dwc_diepctl0_reg_t ctl = {};
616 ctl.mps = ESPUSBDetail::EncodeEp0Mps(cfg.max_packet_size);
617 ctl.usbactep = 1;
618 ctl.eptype = static_cast<uint32_t>(cfg.type);
619 ctl.txfnum = 0;
620 dev->diepctl0_reg.val = ctl.val;
621 }
622 else
623 {
624 usb_dwc_diepctl_reg_t ctl = {};
625 ctl.mps = cfg.max_packet_size;
626 ctl.usbactep = 1;
627 ctl.eptype = static_cast<uint32_t>(cfg.type);
628 ctl.txfnum = ep_num;
629 ctl.setd0pid = 1;
630 dev->in_eps[ep_num - 1U].diepctl_reg.val = ctl.val;
631 }
632 dev->daintmsk_reg.val |= (1UL << ep_num);
633 }
634 else
635 {
636 if (ep_num == 0U)
637 {
638 usb_dwc_doepctl0_reg_t ctl = {};
639 ctl.mps = ESPUSBDetail::EncodeEp0Mps(cfg.max_packet_size);
640 ctl.usbactep = 1;
641 ctl.eptype = static_cast<uint32_t>(cfg.type);
642 dev->doepctl0_reg.val = ctl.val;
643 }
644 else
645 {
646 usb_dwc_doepctl_reg_t ctl = {};
647 ctl.mps = cfg.max_packet_size;
648 ctl.usbactep = 1;
649 ctl.eptype = static_cast<uint32_t>(cfg.type);
650 ctl.setd0pid = 1;
651 dev->out_eps[ep_num - 1U].doepctl_reg.val = ctl.val;
652 }
653 dev->daintmsk_reg.val |= (1UL << (16U + ep_num));
654 }
655}
656
657void ESP32USBEndpoint::ProgramTransfer(size_t size)
658{
659 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
660 const uint8_t ep_num = EPNumberToInt8(GetNumber());
661 const uint16_t pkt_count = ESPUSBDetail::PacketCount(size, MaxPacketSize());
662
663 if (GetDirection() == Direction::IN)
664 {
665 if (ep_num == 0U)
666 {
667 dev->dieptsiz0_reg.xfersize = static_cast<uint32_t>(size);
668 dev->dieptsiz0_reg.pktcnt = pkt_count;
669 if (device_.DmaEnabled() && (size > 0U))
670 {
671 dev->diepdma0_reg.dmaaddr =
672 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(transfer_hw_buffer_));
673 }
674 ESPUSBDetail::StartEndpointTransfer(dev->diepctl0_reg);
675 }
676 else
677 {
678 auto& tsiz = dev->in_eps[ep_num - 1U].dieptsiz_reg;
679 tsiz.xfersize = static_cast<uint32_t>(size);
680 tsiz.pktcnt = pkt_count;
681 tsiz.mc = 1U;
682 if (device_.DmaEnabled() && (size > 0U))
683 {
684 dev->in_eps[ep_num - 1U].diepdma_reg.dmaddr =
685 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(transfer_hw_buffer_));
686 }
687 ESPUSBDetail::StartEndpointTransfer(dev->in_eps[ep_num - 1U].diepctl_reg);
688 }
689
690 if (!device_.DmaEnabled() && (size > 0U))
691 {
692 WriteMoreTxData();
693 if ((ep_num != 0U) && (transfer_queued_size_ < transfer_request_size_))
694 {
695 dev->diepempmsk_reg.val |= (1UL << ep_num);
696 }
697 }
698 }
699 else
700 {
701 if (ep_num == 0U)
702 {
703 dev->doeptsiz0_reg.val = 0U;
704 dev->doeptsiz0_reg.xfersize =
705 static_cast<uint32_t>((size == 0U) ? MaxPacketSize() : size);
706 dev->doeptsiz0_reg.pktcnt = pkt_count;
707 if (device_.DmaEnabled() && (size > 0U))
708 {
709 dev->doepdma0_reg.dmaaddr =
710 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(transfer_hw_buffer_));
711 }
712 ESPUSBDetail::StartEndpointTransfer(dev->doepctl0_reg);
713 }
714 else
715 {
716 auto& tsiz = dev->out_eps[ep_num - 1U].doeptsiz_reg;
717 tsiz.xfersize = static_cast<uint32_t>(size);
718 tsiz.pktcnt = pkt_count;
719 tsiz.rxdpid = 0U;
720 if (device_.DmaEnabled() && (size > 0U))
721 {
722 dev->out_eps[ep_num - 1U].doepdma_reg.dmaaddr =
723 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(transfer_hw_buffer_));
724 }
725 ESPUSBDetail::StartEndpointTransfer(dev->out_eps[ep_num - 1U].doepctl_reg);
726 }
727 }
728}
729
730void ESP32USBEndpoint::WriteMoreTxData()
731{
732 if (transfer_buffer_ == nullptr || transfer_queued_size_ >= transfer_request_size_)
733 {
734 return;
735 }
736
737 auto* dev = reinterpret_cast<usb_dwc_dev_t*>(ESPUSBDetail::DWC2_FS_REG_BASE);
738 const uint8_t ep_num = EPNumberToInt8(GetNumber());
739 const volatile uint32_t* fifo = ESPUSBDetail::GetEndpointFifo(dev, ep_num);
740
741 while (transfer_queued_size_ < transfer_request_size_)
742 {
743 uint16_t fifo_words = 0U;
744 if (ep_num == 0U)
745 {
746 fifo_words = dev->dtxfsts0_reg.ineptxfspcavail;
747 }
748 else
749 {
750 fifo_words = dev->in_eps[ep_num - 1U].dtxfsts_reg.ineptxfspcavail;
751 }
752
753 const size_t remaining = transfer_request_size_ - transfer_queued_size_;
754 const size_t packet_size = std::min(remaining, static_cast<size_t>(MaxPacketSize()));
755 if (packet_size > static_cast<size_t>(fifo_words) * 4U)
756 {
757 break;
758 }
759
760 ESPUSBDetail::WriteFifoPacket(const_cast<volatile uint32_t*>(fifo),
761 transfer_buffer_ + transfer_queued_size_, packet_size);
762 transfer_queued_size_ += packet_size;
763 }
764}
765
766} // namespace LibXR
767
768#endif
LibXR
LibXR 命名空间
Definition ch32_can.hpp:14
LibXR::ErrorCode
ErrorCode
定义错误码枚举
Definition libxr_def.hpp:136