X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fstmf0%2Fao_usb_stm.c;h=b736d389c95002e0eae33bcf40028b8d557909b5;hb=refs%2Fheads%2Fmaster;hp=bf08abc169dac58e74da45f81ab2ea1f64c5277e;hpb=48d164e3d4b2ef27fae20fae63b8014803a7b178;p=fw%2Faltos diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c index bf08abc1..0525d11f 100644 --- a/src/stmf0/ao_usb_stm.c +++ b/src/stmf0/ao_usb_stm.c @@ -113,6 +113,12 @@ static uint8_t ao_usb_in_tx2_which; static uint8_t ao_usb_tx2_count; #endif +#if AO_USB_HAS_IN3 +static uint16_t ao_usb_in_tx3_offset; +static uint8_t ao_usb_in_tx3_which; +static uint8_t ao_usb_tx3_count; +#endif + /* * End point register indices */ @@ -122,6 +128,7 @@ static uint8_t ao_usb_tx2_count; #define AO_USB_OUT_EPR 2 #define AO_USB_IN_EPR 3 #define AO_USB_IN2_EPR 4 +#define AO_USB_IN3_EPR 5 /* Marks when we don't need to send an IN packet. * This happens only when the last IN packet is not full, @@ -146,6 +153,16 @@ static uint16_t in2_count; static uint8_t ao_usb_in2_flushed; #endif +#if AO_USB_HAS_IN3 +/* Marks when we have delivered an IN packet to the hardware + * and it has not been received yet. ao_sleep on this address + * to wait for it to be delivered. + */ +static uint8_t ao_usb_in3_pending; +static uint16_t in3_count; +static uint8_t ao_usb_in3_flushed; +#endif + /* Marks when an OUT packet has been received by the hardware * but not pulled to the shadow buffer. */ @@ -228,7 +245,7 @@ static inline uint32_t ao_usb_epr_sw_buf_rx(uint32_t epr) { * Set current device address and mark the * interface as active */ -void +static void ao_usb_set_address(uint8_t address) { debug("ao_usb_set_address %02x\n", address); @@ -300,9 +317,9 @@ _ao_usb_set_stat_tx(int ep, uint32_t stat_tx) epr_old = epr_write = stm_usb.epr[ep].r; epr_write &= STM_USB_EPR_PRESERVE_MASK; epr_write |= STM_USB_EPR_INVARIANT; - epr_write |= set_toggle(epr_old, - STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX, - stat_tx << STM_USB_EPR_STAT_TX); + epr_write |= (uint16_t) set_toggle(epr_old, + STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX, + stat_tx << STM_USB_EPR_STAT_TX); stm_usb.epr[ep].r = epr_write; _tx_dbg1("set_stat_tx bottom", epr_write); } @@ -324,8 +341,8 @@ _ao_usb_toggle_dtog(int ep, uint32_t dtog_rx, uint32_t dtog_tx) epr_write = stm_usb.epr[ep].r; epr_write &= STM_USB_EPR_PRESERVE_MASK; epr_write |= STM_USB_EPR_INVARIANT; - epr_write |= ((dtog_rx << STM_USB_EPR_DTOG_RX) | - (dtog_tx << STM_USB_EPR_DTOG_TX)); + epr_write |= (uint16_t) ((dtog_rx << STM_USB_EPR_DTOG_RX) | + (dtog_tx << STM_USB_EPR_DTOG_TX)); stm_usb.epr[ep].r = epr_write; _tx_dbg1("toggle_dtog bottom", epr_write); } @@ -337,9 +354,9 @@ _ao_usb_set_stat_rx(int ep, uint32_t stat_rx) { epr_write = epr_old = stm_usb.epr[ep].r; epr_write &= STM_USB_EPR_PRESERVE_MASK; epr_write |= STM_USB_EPR_INVARIANT; - epr_write |= set_toggle(epr_old, - STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX, - stat_rx << STM_USB_EPR_STAT_RX); + epr_write |= (uint16_t) set_toggle(epr_old, + STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX, + stat_rx << STM_USB_EPR_STAT_RX); stm_usb.epr[ep].r = epr_write; } @@ -364,22 +381,22 @@ ao_usb_init_ep(uint8_t ep, uint16_t addr, uint16_t type, ao_arch_block_interrupts(); epr = stm_usb.epr[ep].r; - epr = ((0 << STM_USB_EPR_CTR_RX) | - (type << STM_USB_EPR_EP_TYPE) | - (kind << STM_USB_EPR_EP_KIND) | - (0 << STM_USB_EPR_CTR_TX) | - (addr << STM_USB_EPR_EA) | - set_toggle(epr, - - (1 << STM_USB_EPR_DTOG_RX) | - (STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX) | - (1 << STM_USB_EPR_DTOG_TX) | - (STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX), - - (dtog_rx << STM_USB_EPR_DTOG_RX) | - (stat_rx << STM_USB_EPR_STAT_RX) | - (dtog_tx << STM_USB_EPR_DTOG_TX) | - (stat_tx << STM_USB_EPR_STAT_TX))); + epr = (uint16_t) ((0UL << STM_USB_EPR_CTR_RX) | + ((uint32_t) type << STM_USB_EPR_EP_TYPE) | + ((uint32_t) kind << STM_USB_EPR_EP_KIND) | + (0UL << STM_USB_EPR_CTR_TX) | + ((uint32_t) addr << STM_USB_EPR_EA) | + set_toggle(epr, + + (1UL << STM_USB_EPR_DTOG_RX) | + (STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX) | + (1UL << STM_USB_EPR_DTOG_TX) | + (STM_USB_EPR_STAT_TX_MASK << STM_USB_EPR_STAT_TX), + + ((uint32_t) dtog_rx << STM_USB_EPR_DTOG_RX) | + ((uint32_t) stat_rx << STM_USB_EPR_STAT_RX) | + ((uint32_t) dtog_tx << STM_USB_EPR_DTOG_TX) | + ((uint32_t) stat_tx << STM_USB_EPR_STAT_TX))); stm_usb.epr[ep].r = epr; ao_arch_release_interrupts(); debug ("writing epr[%d] 0x%04x wrote 0x%04x\n", @@ -401,28 +418,33 @@ ao_usb_alloc_buffers(void) sram_addr += AO_USB_CONTROL_SIZE; #if AO_USB_HAS_INT - sram_addr += (sram_addr & 1); + sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1)); ao_usb_int_tx_offset = sram_addr; sram_addr += AO_USB_INT_SIZE; #endif #if AO_USB_HAS_OUT - sram_addr += (sram_addr & 1); + sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1)); ao_usb_out_rx_offset = sram_addr; sram_addr += AO_USB_OUT_SIZE * 2; #endif #if AO_USB_HAS_IN - sram_addr += (sram_addr & 1); + sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1)); ao_usb_in_tx_offset = sram_addr; sram_addr += AO_USB_IN_SIZE * 2; #endif #if AO_USB_HAS_IN2 - sram_addr += (sram_addr & 1); + sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1)); ao_usb_in_tx2_offset = sram_addr; sram_addr += AO_USB_IN_SIZE * 2; #endif +#if AO_USB_HAS_IN3 + sram_addr = (uint16_t) ((uint16_t) sram_addr + (uint16_t) (sram_addr & 1)); + ao_usb_in_tx3_offset = sram_addr; + sram_addr += AO_USB_IN_SIZE * 2; +#endif } static void @@ -441,7 +463,7 @@ ao_usb_init_btable(void) static void ao_usb_set_ep0(void) { - int e; + uint8_t e; ao_usb_init_btable(); @@ -558,6 +580,25 @@ ao_usb_set_configuration(void) ao_usb_in_tx2_which = 0; #endif +#if AO_USB_HAS_IN3 + /* Set up the IN3 end point */ + stm_usb_bdt[AO_USB_IN3_EPR].double_tx[0].addr = ao_usb_in_tx3_offset; + stm_usb_bdt[AO_USB_IN3_EPR].double_tx[0].count = 0; + stm_usb_bdt[AO_USB_IN3_EPR].double_tx[1].addr = ao_usb_in_tx3_offset + AO_USB_IN_SIZE; + stm_usb_bdt[AO_USB_IN3_EPR].double_tx[1].count = 0; + + ao_usb_init_ep(AO_USB_IN3_EPR, + AO_USB_IN3_EP, + STM_USB_EPR_EP_TYPE_BULK, + STM_USB_EPR_STAT_RX_DISABLED, + STM_USB_EPR_STAT_TX_NAK, + STM_USB_EPR_EP_KIND_DBL_BUF, + 0, 1); + + /* First transmit data goes to buffer 0 */ + ao_usb_in_tx3_which = 0; +#endif + ao_usb_in_flushed = 0; ao_usb_in_pending = 0; ao_wakeup(&ao_usb_in_pending); @@ -567,6 +608,12 @@ ao_usb_set_configuration(void) ao_wakeup(&ao_usb_in2_pending); #endif +#if AO_USB_HAS_IN3 + ao_usb_in3_flushed = 0; + ao_usb_in3_pending = 0; + ao_wakeup(&ao_usb_in3_pending); +#endif + ao_usb_out_avail = 0; ao_usb_configuration = 0; @@ -594,7 +641,7 @@ ao_usb_tx_byte(uint16_t offset, uint8_t byte) { if (offset & 1) ao_usb_packet_put(offset - 1, - ao_usb_packet_get(offset - 1) | ((uint16_t) byte) << 8); + (uint16_t) (ao_usb_packet_get(offset - 1) | ((uint16_t) byte) << 8)); else ao_usb_packet_put(offset, (uint16_t) byte); } @@ -662,7 +709,7 @@ ao_usb_ep0_fill(void) if (len > ao_usb_ep0_out_len) len = ao_usb_ep0_out_len; - ao_usb_ep0_out_len -= len; + ao_usb_ep0_out_len -= (uint8_t) len; /* Pull all of the data out of the packet */ debug_data ("Fill EP0 len %d:", len); @@ -707,7 +754,7 @@ ao_usb_ep0_in_start(uint16_t max) { /* Don't send more than asked for */ if (ao_usb_ep0_in_len > max) - ao_usb_ep0_in_len = max; + ao_usb_ep0_in_len = (uint8_t) max; ao_usb_ep0_flush(); } @@ -724,7 +771,7 @@ hex_to_ucs2(uint32_t in, uint8_t *out) for (i = 28; i >= 0; i -= 4) { uint8_t bits = (in >> i) & 0xf; - *out++ = ((bits < 10) ? '0' : ('a' - 10)) + bits; + *out++ = (uint8_t) (((bits < 10) ? '0' : ('a' - 10)) + bits); *out++ = 0; } } @@ -749,8 +796,8 @@ static void ao_usb_get_descriptor(uint16_t value, uint16_t length) { const uint8_t *descriptor; - uint8_t type = value >> 8; - uint8_t index = value; + uint8_t type = (uint8_t) (value >> 8); + uint8_t index = (uint8_t) value; descriptor = ao_usb_descriptors; while (descriptor[0] != 0) { @@ -768,7 +815,7 @@ ao_usb_get_descriptor(uint16_t value, uint16_t length) } #endif if (len > length) - len = length; + len = (uint8_t) length; ao_usb_ep0_in_set(descriptor, len); break; } @@ -808,7 +855,7 @@ ao_usb_ep0_setup(void) break; case AO_USB_REQ_SET_ADDRESS: debug ("set address %d\n", ao_usb_setup.value); - ao_usb_address = ao_usb_setup.value; + ao_usb_address = (uint8_t) ao_usb_setup.value; ao_usb_address_pending = 1; break; case AO_USB_REQ_GET_DESCRIPTOR: @@ -820,7 +867,7 @@ ao_usb_ep0_setup(void) ao_usb_ep0_in_queue_byte(ao_usb_configuration); break; case AO_USB_REQ_SET_CONFIGURATION: - ao_usb_configuration = ao_usb_setup.value; + ao_usb_configuration = (uint8_t) ao_usb_setup.value; debug ("set configuration %d\n", ao_usb_configuration); ao_usb_set_configuration(); break; @@ -910,7 +957,7 @@ ao_usb_ep0_handle(uint8_t receive) } #if AO_POWER_MANAGEMENT -void +static void ao_usb_suspend(void) { stm_usb.cntr |= (1 << STM_USB_CNTR_FSUSP); @@ -919,11 +966,11 @@ ao_usb_suspend(void) ao_clock_suspend(); } -void +static void ao_usb_wakeup(void) { ao_clock_resume(); - stm_usb.cntr &= ~(1 << STM_USB_CNTR_FSUSP); + stm_usb.cntr &= (uint16_t) ~(1 << STM_USB_CNTR_FSUSP); ao_power_resume(); } #endif @@ -933,7 +980,7 @@ stm_usb_isr(void) { uint32_t istr = stm_usb.istr; - stm_usb.istr = ~istr; + stm_usb.istr = (uint16_t) ~istr; if (istr & (1 << STM_USB_ISTR_CTR)) { uint8_t ep = istr & STM_USB_ISTR_EP_ID_MASK; uint16_t epr, epr_write; @@ -945,8 +992,8 @@ stm_usb_isr(void) epr_write = epr; epr_write &= STM_USB_EPR_PRESERVE_MASK; epr_write |= STM_USB_EPR_INVARIANT; - epr_write &= ~(1 << STM_USB_EPR_CTR_RX); - epr_write &= ~(1 << STM_USB_EPR_CTR_TX); + epr_write &= (uint16_t) ~(1 << STM_USB_EPR_CTR_RX); + epr_write &= (uint16_t) ~(1 << STM_USB_EPR_CTR_TX); stm_usb.epr[ep].r = epr_write; switch (ep) { @@ -995,6 +1042,16 @@ stm_usb_isr(void) ao_wakeup(&ao_usb_in2_pending); } break; +#endif +#if AO_USB_HAS_IN3 + case AO_USB_IN3_EPR: + ++in3_count; + _tx_dbg1("TX3 ISR", epr); + if (ao_usb_epr_ctr_tx(epr)) { + ao_usb_in3_pending = 0; + ao_wakeup(&ao_usb_in3_pending); + } + break; #endif case AO_USB_INT_EPR: #if USB_STATUS @@ -1102,7 +1159,7 @@ ao_usb_putchar(char c) _ao_usb_in_wait(); ao_usb_in_flushed = 0; - ao_usb_tx_byte(ao_usb_in_tx_offset + AO_USB_IN_SIZE * ao_usb_in_tx_which + ao_usb_tx_count++, c); + ao_usb_tx_byte((uint16_t) (ao_usb_in_tx_offset + AO_USB_IN_SIZE * ao_usb_in_tx_which + ao_usb_tx_count++), c); /* Send the packet when full */ if (ao_usb_tx_count == AO_USB_IN_SIZE) { @@ -1132,6 +1189,9 @@ _ao_usb_in2_send(void) /* Toggle our usage */ ao_usb_in_tx2_which = 1 - ao_usb_in_tx2_which; + /* Toggle the SW_BUF flag */ + _ao_usb_toggle_dtog(AO_USB_IN2_EPR, 1, 0); + /* Mark the outgoing buffer as valid */ _ao_usb_set_stat_tx(AO_USB_IN2_EPR, STM_USB_EPR_STAT_TX_VALID); @@ -1187,7 +1247,7 @@ ao_usb_putchar2(char c) _ao_usb_in2_wait(); ao_usb_in2_flushed = 0; - ao_usb_tx_byte(ao_usb_in_tx2_offset + AO_USB_IN_SIZE * ao_usb_in_tx2_which + ao_usb_tx2_count++, c); + ao_usb_tx_byte((uint16_t) (ao_usb_in_tx2_offset + AO_USB_IN_SIZE * ao_usb_in_tx2_which + ao_usb_tx2_count++), c); /* Send the packet when full */ if (ao_usb_tx2_count == AO_USB_IN_SIZE) { @@ -1199,6 +1259,94 @@ ao_usb_putchar2(char c) } #endif +#if AO_USB_HAS_IN3 +/* Queue the current IN buffer for transmission */ +static void +_ao_usb_in3_send(void) +{ + _tx_dbg0("in3_send start"); + debug ("send3 %d\n", ao_usb_tx3_count); + while (ao_usb_in3_pending) + ao_sleep(&ao_usb_in3_pending); + ao_usb_in3_pending = 1; + if (ao_usb_tx3_count != AO_USB_IN_SIZE) + ao_usb_in3_flushed = 1; + stm_usb_bdt[AO_USB_IN3_EPR].double_tx[ao_usb_in_tx3_which].count = ao_usb_tx3_count; + ao_usb_tx3_count = 0; + + /* Toggle our usage */ + ao_usb_in_tx3_which = 1 - ao_usb_in_tx3_which; + + /* Toggle the SW_BUF flag */ + _ao_usb_toggle_dtog(AO_USB_IN3_EPR, 1, 0); + + /* Mark the outgoing buffer as valid */ + _ao_usb_set_stat_tx(AO_USB_IN3_EPR, STM_USB_EPR_STAT_TX_VALID); + + _tx_dbg0("in3_send end"); +} + +/* Wait for a free IN buffer. Interrupts are blocked */ +static void +_ao_usb_in3_wait(void) +{ + for (;;) { + /* Check if the current buffer is writable */ + if (ao_usb_tx3_count < AO_USB_IN_SIZE) + break; + + _tx_dbg0("in3_wait top"); + /* Wait for an IN buffer to be ready */ + while (ao_usb_in3_pending) + ao_sleep(&ao_usb_in3_pending); + _tx_dbg0("in_wait bottom"); + } +} + +void +ao_usb_flush3(void) +{ + if (!ao_usb_running) + return; + + /* Anytime we've sent a character since + * the last time we flushed, we'll need + * to send a packet -- the only other time + * we would send a packet is when that + * packet was full, in which case we now + * want to send an empty packet + */ + ao_arch_block_interrupts(); + while (!ao_usb_in3_flushed) { + _tx_dbg0("flush3 top"); + _ao_usb_in3_send(); + _tx_dbg0("flush3 end"); + } + ao_arch_release_interrupts(); +} + +void +ao_usb_putchar3(char c) +{ + if (!ao_usb_running) + return; + + ao_arch_block_interrupts(); + _ao_usb_in3_wait(); + + ao_usb_in3_flushed = 0; + ao_usb_tx_byte((uint16_t) (ao_usb_in_tx3_offset + AO_USB_IN_SIZE * ao_usb_in_tx3_which + ao_usb_tx3_count++), c); + + /* Send the packet when full */ + if (ao_usb_tx3_count == AO_USB_IN_SIZE) { + _tx_dbg0("putchar3 full"); + _ao_usb_in3_send(); + _tx_dbg0("putchar3 flushed"); + } + ao_arch_release_interrupts(); +} +#endif + #if AO_USB_HAS_OUT static void _ao_usb_out_recv(void) @@ -1211,7 +1359,7 @@ _ao_usb_out_recv(void) /* Switch to new buffer */ ao_usb_out_rx_which = 1 - ao_usb_out_rx_which; - ao_usb_rx_count = stm_usb_bdt[AO_USB_OUT_EPR].double_rx[ao_usb_out_rx_which].count & STM_USB_BDT_COUNT_RX_COUNT_RX_MASK; + ao_usb_rx_count = (uint8_t) (stm_usb_bdt[AO_USB_OUT_EPR].double_rx[ao_usb_out_rx_which].count & STM_USB_BDT_COUNT_RX_COUNT_RX_MASK); ao_usb_rx_pos = 0; /* Toggle the SW_BUF_RX bit */ @@ -1223,7 +1371,7 @@ _ao_usb_out_recv(void) _rx_dbg1("out_recv count", ao_usb_rx_count); } -int +static int _ao_usb_pollchar(void) { uint8_t c; @@ -1245,7 +1393,7 @@ _ao_usb_pollchar(void) } /* Pull a character out of the fifo */ - c = ao_usb_rx_byte(ao_usb_out_rx_offset + ao_usb_out_rx_which * AO_USB_OUT_SIZE + ao_usb_rx_pos++); + c = ao_usb_rx_byte((uint16_t) (ao_usb_out_rx_offset + ao_usb_out_rx_which * AO_USB_OUT_SIZE + ao_usb_rx_pos++)); _rx_dbg1("char", c); return c; } @@ -1259,7 +1407,7 @@ ao_usb_getchar(void) while ((c = _ao_usb_pollchar()) == AO_READ_AGAIN) ao_sleep(AO_USB_OUT_SLEEP_ADDR); ao_arch_release_interrupts(); - return c; + return (char) c; } #endif @@ -1373,13 +1521,13 @@ ao_usb_disable(void) stm_usb.istr = 0; /* Disable USB pull-up */ - stm_usb.bcdr &= ~(1 << STM_USB_BCDR_DPPU); + stm_usb.bcdr &= (uint16_t) ~(1 << STM_USB_BCDR_DPPU); /* Switch off the device */ stm_usb.cntr = (1 << STM_USB_CNTR_PDWN) | (1 << STM_USB_CNTR_FRES); /* Disable the interface */ - stm_rcc.apb1enr &= ~(1 << STM_RCC_APB1ENR_USBEN); + stm_rcc.apb1enr &= ~(1UL << STM_RCC_APB1ENR_USBEN); ao_arch_release_interrupts(); } @@ -1389,16 +1537,16 @@ ao_usb_enable(void) int t; /* Select HSI48 as USB clock source */ - stm_rcc.cfgr3 &= ~(1 << STM_RCC_CFGR3_USBSW); + stm_rcc.cfgr3 &= ~(1UL << STM_RCC_CFGR3_USBSW); /* Enable USB device */ stm_rcc.apb1enr |= (1 << STM_RCC_APB1ENR_USBEN); /* Clear reset condition */ - stm_rcc.apb1rstr &= ~(1 << STM_RCC_APB1RSTR_USBRST); + stm_rcc.apb1rstr &= ~(1UL << STM_RCC_APB1RSTR_USBRST); /* Disable USB pull-up */ - stm_usb.bcdr &= ~(1 << STM_USB_BCDR_DPPU); + stm_usb.bcdr &= (uint16_t) ~(1 << STM_USB_BCDR_DPPU); /* Do not touch the GPIOA configuration; USB takes priority * over GPIO on pins A11 and A12, but if you select alternate @@ -1447,7 +1595,7 @@ ao_usb_enable(void) ao_arch_release_interrupts(); - for (t = 0; t < 1000; t++) + for (t = 0; t < 50000; t++) ao_arch_nop(); /* Enable USB pull-up */ @@ -1478,7 +1626,7 @@ ao_usb_irq(void) control_count, out_count, in_count, int_count, reset_count); } -__code struct ao_cmds ao_usb_cmds[] = { +const struct ao_cmds ao_usb_cmds[] = { { ao_usb_irq, "I\0Show USB interrupt counts" }, { 0, NULL } }; @@ -1541,9 +1689,9 @@ struct ao_usb_dbg { #endif }; -#define NUM_USB_DBG 128 +#define NUM_USB_DBG 16 -struct ao_usb_dbg dbg[128]; +struct ao_usb_dbg dbg[NUM_USB_DBG]; int dbg_i; static void _dbg(int line, char *msg, uint32_t value) @@ -1555,11 +1703,11 @@ static void _dbg(int line, char *msg, uint32_t value) asm("mrs %0,primask" : "=&r" (primask)); dbg[dbg_i].primask = primask; #if TX_DBG - dbg[dbg_i].in_count = in_count; - dbg[dbg_i].in_epr = stm_usb.epr[AO_USB_IN_EPR]; - dbg[dbg_i].in_pending = ao_usb_in_pending; - dbg[dbg_i].tx_count = ao_usb_tx_count; - dbg[dbg_i].in_flushed = ao_usb_in_flushed; + dbg[dbg_i].in_count = in3_count; + dbg[dbg_i].in_epr = stm_usb.epr[AO_USB_IN3_EPR].r; + dbg[dbg_i].in_pending = ao_usb_in3_pending; + dbg[dbg_i].tx_count = ao_usb_tx3_count; + dbg[dbg_i].in_flushed = ao_usb_in3_flushed; #endif #if RX_DBG dbg[dbg_i].rx_count = ao_usb_rx_count;