X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fstmf0%2Fao_usb_stm.c;h=0963b64a8d7232f84b906c5baab277536e15d5f3;hb=42072f591690b8258d957ab7a9b2f5d911676b39;hp=6393ee4477eb2d1a1ef40d98e31cbab3ecc4a02f;hpb=1704d27248f1845c545ec61cf1bad58bf41189af;p=fw%2Faltos diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c index 6393ee44..0963b64a 100644 --- a/src/stmf0/ao_usb_stm.c +++ b/src/stmf0/ao_usb_stm.c @@ -3,7 +3,8 @@ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; version 2 of the License. + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of @@ -98,12 +99,9 @@ static uint16_t ao_usb_int_tx_offset; /* Pointer to bulk data tx/rx buffers in USB memory */ #if AO_USB_HAS_IN -static uint16_t ao_usb_in_tx_offset; -static uint16_t *ao_usb_in_tx_buffer; - -/* System ram shadow of USB buffer; writing individual bytes is - * too much of a pain (sigh) */ -static uint8_t ao_usb_tx_buffer[AO_USB_IN_SIZE]; +static uint16_t ao_usb_in_tx_offset[2]; +static uint16_t *ao_usb_in_tx_buffer[2]; +static uint8_t ao_usb_in_tx_which; static uint8_t ao_usb_tx_count; #endif @@ -118,12 +116,9 @@ static uint8_t ao_usb_rx_count, ao_usb_rx_pos; #endif #if AO_USB_HAS_IN2 -static uint16_t ao_usb_in2_tx_offset; -static uint16_t *ao_usb_in2_tx_buffer; - -/* System ram shadow of USB buffer; writing individual bytes is - * too much of a pain (sigh) */ -static uint8_t ao_usb_tx2_buffer[AO_USB_IN_SIZE]; +static uint16_t ao_usb_in2_tx_offset[2]; +static uint16_t *ao_usb_in2_tx_buffer[2]; +static uint8_t ao_usb_in_tx2_which; static uint8_t ao_usb_tx2_count; #endif @@ -184,7 +179,7 @@ static inline uint32_t set_toggle(uint32_t current_value, static inline uint16_t *ao_usb_packet_buffer_addr(uint16_t sram_addr) { - return (uint16_t *) (stm_usb_sram + sram_addr); + return (uint16_t *) (void *) (stm_usb_sram + sram_addr); } static inline uint16_t ao_usb_packet_buffer_offset(uint16_t *addr) @@ -297,12 +292,27 @@ _ao_usb_set_stat_tx(int ep, uint32_t stat_tx) 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); + 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); } +static void +_ao_usb_toggle_dtog(int ep, uint32_t dtog_rx, uint32_t dtog_tx) +{ + uint16_t epr_write; + + _tx_dbg1("toggle_dtog top", dtog_rx); + 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)); + stm_usb.epr[ep].r = epr_write; + _tx_dbg1("toggle_dtog bottom", epr_write); +} + static void ao_usb_set_stat_tx(int ep, uint32_t stat_tx) { @@ -336,25 +346,28 @@ ao_usb_set_stat_rx(int ep, uint32_t stat_rx) { */ static void -ao_usb_init_ep(uint8_t ep, uint32_t addr, uint32_t type, uint32_t stat_rx, uint32_t stat_tx) +ao_usb_init_ep(uint8_t ep, uint32_t addr, uint32_t type, uint32_t stat_rx, uint32_t stat_tx, uint32_t kind, uint32_t dtog_rx, uint32_t dtog_tx) { uint16_t epr; ao_arch_block_interrupts(); epr = stm_usb.epr[ep].r; epr = ((0 << STM_USB_EPR_CTR_RX) | - (epr & (1 << STM_USB_EPR_DTOG_RX)) | - set_toggle(epr, - (STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX), - (stat_rx << STM_USB_EPR_STAT_RX)) | (type << STM_USB_EPR_EP_TYPE) | - (0 << STM_USB_EPR_EP_KIND) | + (kind << STM_USB_EPR_EP_KIND) | (0 << STM_USB_EPR_CTR_TX) | - (epr & (1 << STM_USB_EPR_DTOG_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), - (stat_tx << STM_USB_EPR_STAT_TX)) | - (addr << STM_USB_EPR_EA)); + + (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))); stm_usb.epr[ep].r = epr; ao_arch_release_interrupts(); debug ("writing epr[%d] 0x%04x wrote 0x%04x\n", @@ -377,29 +390,44 @@ ao_usb_alloc_buffers(void) #if AO_USB_HAS_INT + sram_addr += (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); ao_usb_out_rx_buffer = ao_usb_packet_buffer_addr(sram_addr); ao_usb_out_rx_offset = sram_addr; sram_addr += AO_USB_OUT_SIZE; #endif #if AO_USB_HAS_IN - ao_usb_in_tx_buffer = ao_usb_packet_buffer_addr(sram_addr); - ao_usb_in_tx_offset = sram_addr; + sram_addr += (sram_addr & 1); + ao_usb_in_tx_buffer[0] = ao_usb_packet_buffer_addr(sram_addr); + ao_usb_in_tx_offset[0] = sram_addr; sram_addr += AO_USB_IN_SIZE; + ao_usb_in_tx_buffer[1] = ao_usb_packet_buffer_addr(sram_addr); + ao_usb_in_tx_offset[1] = sram_addr; + sram_addr += AO_USB_IN_SIZE; + ao_usb_in_tx_which = 0; #endif #if AO_USB_HAS_IN2 - ao_usb_in2_tx_buffer = ao_usb_packet_buffer_addr(sram_addr); - ao_usb_in2_tx_offset = sram_addr; + sram_addr += (sram_addr & 1); + ao_usb_in2_tx_buffer[0] = ao_usb_packet_buffer_addr(sram_addr); + ao_usb_in2_tx_offset[0] = sram_addr; + sram_addr += AO_USB_IN_SIZE; + + sram_addr += (sram_addr & 1); + ao_usb_in2_tx_buffer[1] = ao_usb_packet_buffer_addr(sram_addr); + ao_usb_in2_tx_offset[1] = sram_addr; sram_addr += AO_USB_IN_SIZE; + ao_usb_in2_tx_which = 0; #endif #if AO_USB_DIRECTIO + sram_addr += (sram_addr & 1); ao_usb_sram_addr = sram_addr; #endif } @@ -430,14 +458,16 @@ ao_usb_set_ep0(void) ao_usb_init_ep(AO_USB_CONTROL_EPR, AO_USB_CONTROL_EP, STM_USB_EPR_EP_TYPE_CONTROL, STM_USB_EPR_STAT_RX_VALID, - STM_USB_EPR_STAT_TX_NAK); + STM_USB_EPR_STAT_TX_NAK, + STM_USB_EPR_EP_KIND_NO_STATUS_OUT, 0, 0); /* Clear all of the other endpoints */ for (e = 1; e < 8; e++) { ao_usb_init_ep(e, 0, STM_USB_EPR_EP_TYPE_CONTROL, STM_USB_EPR_STAT_RX_DISABLED, - STM_USB_EPR_STAT_TX_DISABLED); + STM_USB_EPR_STAT_TX_DISABLED, + STM_USB_EPR_EP_KIND_SNGL_BUF, 0, 0); } ao_usb_set_address(0); @@ -470,7 +500,8 @@ ao_usb_set_configuration(void) AO_USB_INT_EP, STM_USB_EPR_EP_TYPE_INTERRUPT, STM_USB_EPR_STAT_RX_DISABLED, - STM_USB_EPR_STAT_TX_NAK); + STM_USB_EPR_STAT_TX_NAK, + STM_USB_EPR_EP_KIND_SNGL_BUF, 0, 0); #endif #if AO_USB_HAS_OUT @@ -483,31 +514,39 @@ ao_usb_set_configuration(void) AO_USB_OUT_EP, STM_USB_EPR_EP_TYPE_BULK, STM_USB_EPR_STAT_RX_VALID, - STM_USB_EPR_STAT_TX_DISABLED); + STM_USB_EPR_STAT_TX_DISABLED, + STM_USB_EPR_EP_KIND_SNGL_BUF, 0, 0); #endif #if AO_USB_HAS_IN /* Set up the IN end point */ - ao_usb_bdt[AO_USB_IN_EPR].single.addr_tx = ao_usb_in_tx_offset; - ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = 0; + ao_usb_bdt[AO_USB_IN_EPR].double_tx[0].addr = ao_usb_in_tx_offset[0]; + ao_usb_bdt[AO_USB_IN_EPR].double_tx[0].count = 0; + ao_usb_bdt[AO_USB_IN_EPR].double_tx[1].addr = ao_usb_in_tx_offset[1]; + ao_usb_bdt[AO_USB_IN_EPR].double_tx[1].count = 0; + /* set 'our' buffer to 0, and the device buffer to 1 */ ao_usb_init_ep(AO_USB_IN_EPR, AO_USB_IN_EP, STM_USB_EPR_EP_TYPE_BULK, STM_USB_EPR_STAT_RX_DISABLED, - STM_USB_EPR_STAT_TX_NAK); + STM_USB_EPR_STAT_TX_NAK, + STM_USB_EPR_EP_KIND_DBL_BUF, + 0, 1); #endif #if AO_USB_HAS_IN2 /* Set up the IN2 end point */ - ao_usb_bdt[AO_USB_IN2_EPR].single.addr_tx = ao_usb_in2_tx_offset; + ao_usb_bdt[AO_USB_IN2_EPR].single.addr_tx = 0; ao_usb_bdt[AO_USB_IN2_EPR].single.count_tx = 0; ao_usb_init_ep(AO_USB_IN2_EPR, AO_USB_IN2_EP, STM_USB_EPR_EP_TYPE_BULK, STM_USB_EPR_STAT_RX_DISABLED, - STM_USB_EPR_STAT_TX_NAK); + STM_USB_EPR_STAT_TX_NAK, + STM_USB_EPR_EP_KIND_DBL_BUF, + 0, 1); #endif ao_usb_in_flushed = 0; @@ -530,11 +569,13 @@ ao_usb_set_configuration(void) #endif } +#if USB_STATUS static uint16_t control_count; static uint16_t int_count; static uint16_t in_count; static uint16_t out_count; static uint16_t reset_count; +#endif /* The USB memory must be accessed in 16-bit units */ @@ -565,6 +606,16 @@ ao_usb_copy_rx(uint8_t *dst, uint16_t *base, uint16_t bytes) *dst = *base; } +static uint8_t +ao_usb_tx_byte(uint16_t *base, uint8_t tx_count, char byte) +{ + if (tx_count & 1) + base[tx_count >> 1] |= ((uint16_t) byte) << 8; + else + base[tx_count >> 1] = (uint16_t) (uint8_t) byte; + return tx_count + 1; +} + /* Send an IN data packet */ static void ao_usb_ep0_flush(void) @@ -654,7 +705,7 @@ ao_usb_ep0_in_start(uint16_t max) ao_usb_ep0_flush(); } -static struct ao_usb_line_coding ao_usb_line_coding = {115200, 0, 0, 8}; +struct ao_usb_line_coding ao_usb_line_coding = {115200, 0, 0, 8}; #if AO_USB_DEVICE_ID_SERIAL static uint8_t ao_usb_serial[2 + 48]; @@ -894,7 +945,9 @@ stm_usb_isr(void) switch (ep) { case 0: +#if USB_STATUS ++control_count; +#endif if (ao_usb_epr_ctr_rx(epr)) { if (ao_usb_epr_setup(epr)) ao_usb_ep0_receive |= AO_USB_EP0_GOT_SETUP; @@ -906,7 +959,9 @@ stm_usb_isr(void) ao_usb_ep0_handle(ao_usb_ep0_receive); break; case AO_USB_OUT_EPR: +#if USB_STATUS ++out_count; +#endif if (ao_usb_epr_ctr_rx(epr)) { _rx_dbg1("RX ISR", epr); ao_usb_out_avail = 1; @@ -916,7 +971,9 @@ stm_usb_isr(void) } break; case AO_USB_IN_EPR: +#if USB_STATUS ++in_count; +#endif _tx_dbg1("TX ISR", epr); if (ao_usb_epr_ctr_tx(epr)) { ao_usb_in_pending = 0; @@ -934,7 +991,9 @@ stm_usb_isr(void) break; #endif case AO_USB_INT_EPR: +#if USB_STATUS ++int_count; +#endif if (ao_usb_epr_ctr_tx(epr)) _ao_usb_set_stat_tx(AO_USB_INT_EPR, STM_USB_EPR_STAT_TX_NAK); break; @@ -943,7 +1002,9 @@ stm_usb_isr(void) } if (istr & (1 << STM_USB_ISTR_RESET)) { +#if USB_STATUS ++reset_count; +#endif debug ("\treset\n"); ao_usb_set_ep0(); } @@ -971,11 +1032,18 @@ _ao_usb_in_send(void) ao_usb_in_pending = 1; if (ao_usb_tx_count != AO_USB_IN_SIZE) ao_usb_in_flushed = 1; - ao_usb_copy_tx(ao_usb_tx_buffer, ao_usb_in_tx_buffer, ao_usb_tx_count); - ao_usb_bdt[AO_USB_IN_EPR].single.addr_tx = ao_usb_in_tx_offset; - ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = ao_usb_tx_count; + ao_usb_bdt[AO_USB_IN_EPR].double_tx[ao_usb_in_tx_which].count = ao_usb_tx_count; ao_usb_tx_count = 0; + + /* Toggle our usage */ + ao_usb_in_tx_which = 1 - ao_usb_in_tx_which; + + /* Toggle the SW_BUF flag */ + _ao_usb_toggle_dtog(AO_USB_IN_EPR, 1, 0); + + /* Mark the outgoing buffer as valid */ _ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID); + _tx_dbg0("in_send end"); } @@ -1028,7 +1096,7 @@ ao_usb_putchar(char c) _ao_usb_in_wait(); ao_usb_in_flushed = 0; - ao_usb_tx_buffer[ao_usb_tx_count++] = (uint8_t) c; + ao_usb_tx_count = ao_usb_tx_byte(ao_usb_in_tx_buffer[ao_usb_in_tx_which], ao_usb_tx_count, c); /* Send the packet when full */ if (ao_usb_tx_count == AO_USB_IN_SIZE) { @@ -1052,10 +1120,10 @@ _ao_usb_in2_send(void) ao_usb_in2_pending = 1; if (ao_usb_tx2_count != AO_USB_IN_SIZE) ao_usb_in2_flushed = 1; - ao_usb_copy_tx(ao_usb_tx2_buffer, ao_usb_in2_tx_buffer, ao_usb_tx2_count); - ao_usb_bdt[AO_USB_IN2_EPR].single.addr_tx = ao_usb_in_tx_offset; - ao_usb_bdt[AO_USB_IN2_EPR].single.count_tx = ao_usb_tx_count; + ao_usb_bdt[AO_USB_IN2_EPR].single.addr_tx = ao_usb_in2_tx_offset[ao_usb_in2_tx_which]; + ao_usb_bdt[AO_USB_IN2_EPR].single.count_tx = ao_usb_tx2_count; ao_usb_tx2_count = 0; + ao_usb_in2_tx_which = 1 - ao_usb_in2_tx_which; _ao_usb_set_stat_tx(AO_USB_IN2_EPR, STM_USB_EPR_STAT_TX_VALID); _tx_dbg0("in2_send end"); } @@ -1109,7 +1177,7 @@ ao_usb_putchar2(char c) _ao_usb_in2_wait(); ao_usb_in2_flushed = 0; - ao_usb_tx2_buffer[ao_usb_tx2_count++] = (uint8_t) c; + ao_usb_tx2_count = ao_usb_tx_byte(ao_usb_in2_tx_buffer[ao_usb_in2_tx_which], ao_usb_tx2_count, c); /* Send the packet when full */ if (ao_usb_tx2_count == AO_USB_IN_SIZE) { @@ -1191,14 +1259,6 @@ ao_usb_alloc(void) return buffer; } -void -ao_usb_free(uint16_t *addr) -{ - uint16_t offset = ao_usb_packet_buffer_offset(addr); - if (offset < ao_usb_sram_addr) - ao_usb_sram_addr = offset; -} - void ao_usb_write(uint16_t *buffer, uint16_t len) {