*
* 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
/* Buffer description tables */
static union stm_usb_bdt *ao_usb_bdt;
/* USB address of end of allocated storage */
+#if AO_USB_DIRECTIO
static uint16_t ao_usb_sram_addr;
+#endif
/* Pointer to ep0 tx/rx buffers in USB memory */
static uint16_t *ao_usb_ep0_tx_buffer;
/* 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
#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
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)
static void
ao_usb_alloc_buffers(void)
{
- ao_usb_sram_addr = 0;
+ uint16_t sram_addr = 0;
ao_usb_bdt = (void *) stm_usb_sram;
- ao_usb_sram_addr += 8 * STM_USB_BDT_SIZE;
+ sram_addr += 8 * STM_USB_BDT_SIZE;
- ao_usb_ep0_tx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
- ao_usb_sram_addr += AO_USB_CONTROL_SIZE;
+ ao_usb_ep0_tx_buffer = ao_usb_packet_buffer_addr(sram_addr);
+ sram_addr += AO_USB_CONTROL_SIZE;
- ao_usb_ep0_rx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
- ao_usb_sram_addr += AO_USB_CONTROL_SIZE;
+ ao_usb_ep0_rx_buffer = ao_usb_packet_buffer_addr(sram_addr);
+ sram_addr += AO_USB_CONTROL_SIZE;
#if AO_USB_HAS_INT
- ao_usb_int_tx_offset = ao_usb_sram_addr;
- ao_usb_sram_addr += AO_USB_INT_SIZE;
+ sram_addr += (sram_addr & 1);
+ ao_usb_int_tx_offset = sram_addr;
+ sram_addr += AO_USB_INT_SIZE;
#endif
#if AO_USB_HAS_OUT
- ao_usb_out_rx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
- ao_usb_out_rx_offset = ao_usb_sram_addr;
- ao_usb_sram_addr += AO_USB_OUT_SIZE;
+ 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(ao_usb_sram_addr);
- ao_usb_in_tx_offset = ao_usb_sram_addr;
- ao_usb_sram_addr += AO_USB_IN_SIZE;
+ 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(ao_usb_sram_addr);
- ao_usb_in2_tx_offset = ao_usb_sram_addr;
- ao_usb_sram_addr += AO_USB_IN_SIZE;
+ 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
}
#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.addr_tx = 0;
ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = 0;
ao_usb_init_ep(AO_USB_IN_EPR,
#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,
#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
*/
*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)
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];
/* Walk through the list of descriptors and find a match
*/
static void
-ao_usb_get_descriptor(uint16_t value)
+ao_usb_get_descriptor(uint16_t value, uint16_t length)
{
const uint8_t *descriptor;
uint8_t type = value >> 8;
len = sizeof (ao_usb_serial);
}
#endif
+ if (len > length)
+ len = length;
ao_usb_ep0_in_set(descriptor, len);
break;
}
break;
case AO_USB_REQ_GET_DESCRIPTOR:
debug ("get descriptor %d\n", ao_usb_setup.value);
- ao_usb_get_descriptor(ao_usb_setup.value);
+ ao_usb_get_descriptor(ao_usb_setup.value, ao_usb_setup.length);
break;
case AO_USB_REQ_GET_CONFIGURATION:
debug ("get configuration %d\n", ao_usb_configuration);
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;
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;
}
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;
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;
}
if (istr & (1 << STM_USB_ISTR_RESET)) {
+#if USB_STATUS
++reset_count;
+#endif
debug ("\treset\n");
ao_usb_set_ep0();
}
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.addr_tx = ao_usb_in_tx_offset[ao_usb_in_tx_which];
ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = ao_usb_tx_count;
ao_usb_tx_count = 0;
+ ao_usb_in_tx_which = 1 - ao_usb_in_tx_which;
_ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
_tx_dbg0("in_send end");
}
_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) {
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");
}
_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) {
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)
{
projects / fw / altos / blobdiff