Skip to content

Commit 66c8c0a

Browse files
warmonkeyfpistm
warmonkey
authored and
fpistm
committed
chore(usb): cdc_queue now use uint32_t length
which allows CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER>512 or CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER>512. Signed-off-by: warmonkey <[email protected]>
1 parent 021d321 commit 66c8c0a

File tree

4 files changed

+55
-49
lines changed

4 files changed

+55
-49
lines changed

‎libraries/USBDevice/inc/cdc_queue.h‎

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -53,45 +53,49 @@ extern "C" {
5353
#else
5454
#define CDC_QUEUE_MAX_PACKET_SIZE USB_FS_MAX_PACKET_SIZE
5555
#endif
56+
57+
#define CDC_TRANSMIT_MAX_BUFFER_SIZE 65472 //STM32 USB OTG DIEPTSIZ PKTCNT maximum 0x3ff
58+
#define CDC_RECEIVE_MAX_BUFFER_SIZE CDC_QUEUE_MAX_PACKET_SIZE
59+
5660
#ifndef CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER
5761
#define CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER 2
5862
#endif
5963
#ifndef CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER
6064
#define CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER 3
6165
#endif
62-
#define CDC_TRANSMIT_QUEUE_BUFFER_SIZE ((uint16_t)(CDC_QUEUE_MAX_PACKET_SIZE * CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER))
63-
#define CDC_RECEIVE_QUEUE_BUFFER_SIZE ((uint16_t)(CDC_QUEUE_MAX_PACKET_SIZE * CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER))
66+
#define CDC_TRANSMIT_QUEUE_BUFFER_SIZE (CDC_QUEUE_MAX_PACKET_SIZE * CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER)
67+
#define CDC_RECEIVE_QUEUE_BUFFER_SIZE (CDC_QUEUE_MAX_PACKET_SIZE * CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER )
6468

6569
typedef struct {
6670
uint8_t buffer[CDC_TRANSMIT_QUEUE_BUFFER_SIZE];
67-
volatile uint16_t write;
68-
volatile uint16_t read;
69-
volatile uint16_t reserved;
71+
volatile uint32_t write;
72+
volatile uint32_t read;
73+
volatile uint32_t reserved;
7074
} CDC_TransmitQueue_TypeDef;
7175

7276
typedef struct {
7377
uint8_t buffer[CDC_RECEIVE_QUEUE_BUFFER_SIZE];
74-
volatile uint16_t write;
75-
volatile uint16_t read;
76-
volatile uint16_t length;
78+
volatile uint32_t write;
79+
volatile uint32_t read;
80+
volatile uint32_t length;
7781
} CDC_ReceiveQueue_TypeDef;
7882

7983
void CDC_TransmitQueue_Init(CDC_TransmitQueue_TypeDef *queue);
8084
int CDC_TransmitQueue_WriteSize(CDC_TransmitQueue_TypeDef *queue);
8185
int CDC_TransmitQueue_ReadSize(CDC_TransmitQueue_TypeDef *queue);
8286
void CDC_TransmitQueue_Enqueue(CDC_TransmitQueue_TypeDef *queue, const uint8_t *buffer, uint32_t size);
83-
uint8_t *CDC_TransmitQueue_ReadBlock(CDC_TransmitQueue_TypeDef *queue, uint16_t *size);
87+
uint8_t *CDC_TransmitQueue_ReadBlock(CDC_TransmitQueue_TypeDef *queue, uint32_t *size);
8488
void CDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef *queue);
8589

8690
void CDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef *queue);
8791
int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue);
8892
int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue);
8993
int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue);
90-
uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue, uint8_t *buffer, uint16_t size);
94+
uint32_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue, uint8_t *buffer, uint32_t size);
9195
bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue, uint8_t terminator, uint8_t *buffer,
92-
uint16_t size, uint16_t *fetched);
96+
uint32_t size, uint32_t *fetched);
9397
uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue);
94-
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue, uint16_t size);
98+
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue, uint32_t size);
9599

96100
#ifdef __cplusplus
97101
}

‎libraries/USBDevice/src/USBSerial.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -107,8 +107,8 @@ int USBSerial::read(void)
107107

108108
size_t USBSerial::readBytes(char *buffer, size_t length)
109109
{
110-
uint16_t read;
111-
auto rest = static_cast<uint16_t>(length);
110+
size_t read;
111+
size_t rest = length;
112112
_startMillis = millis();
113113
do {
114114
read = CDC_ReceiveQueue_Read(&ReceiveQueue, reinterpret_cast<uint8_t *>(buffer), rest);
@@ -124,8 +124,8 @@ size_t USBSerial::readBytes(char *buffer, size_t length)
124124

125125
size_t USBSerial::readBytesUntil(char terminator, char *buffer, size_t length)
126126
{
127-
uint16_t read;
128-
auto rest = static_cast<uint16_t>(length);
127+
uint32_t read;
128+
size_t rest = length;
129129
_startMillis = millis();
130130
do {
131131
bool found = CDC_ReceiveQueue_ReadUntil(&ReceiveQueue, static_cast<uint8_t>(terminator),

‎libraries/USBDevice/src/cdc/cdc_queue.c‎

Lines changed: 33 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -67,32 +67,34 @@ void CDC_TransmitQueue_Enqueue(CDC_TransmitQueue_TypeDef *queue,
6767
{
6868
uint32_t sizeToEnd = CDC_TRANSMIT_QUEUE_BUFFER_SIZE - queue->write;
6969
if (sizeToEnd > size) {
70-
memcpy(&queue->buffer[queue->write], &buffer[0], size);
70+
memcpy(queue->buffer + queue->write, buffer, size);
7171
} else {
72-
memcpy(&queue->buffer[queue->write], &buffer[0], sizeToEnd);
73-
memcpy(&queue->buffer[0], &buffer[sizeToEnd], size - sizeToEnd);
72+
memcpy(queue->buffer + queue->write, buffer, sizeToEnd);
73+
memcpy(queue->buffer, buffer + sizeToEnd, size - sizeToEnd);
7474
}
75-
queue->write = (uint16_t)((queue->write + size) %
76-
CDC_TRANSMIT_QUEUE_BUFFER_SIZE);
75+
queue->write = (queue->write + size) % CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
7776
}
7877

7978
// Read flat block from queue biggest as possible, but max QUEUE_MAX_PACKET_SIZE
8079
uint8_t *CDC_TransmitQueue_ReadBlock(CDC_TransmitQueue_TypeDef *queue,
81-
uint16_t *size)
80+
uint32_t *size)
8281
{
8382
if (queue->write >= queue->read) {
8483
*size = queue->write - queue->read;
8584
} else {
8685
*size = CDC_TRANSMIT_QUEUE_BUFFER_SIZE - queue->read;
8786
}
87+
if (*size > CDC_TRANSMIT_MAX_BUFFER_SIZE) {
88+
*size = CDC_TRANSMIT_MAX_BUFFER_SIZE;
89+
}
90+
8891
queue->reserved = *size;
8992
return &queue->buffer[queue->read];
9093
}
9194

9295
void CDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef *queue)
9396
{
94-
queue->read = (queue->read + queue->reserved) %
95-
CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
97+
queue->read = (queue->read + queue->reserved) % CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
9698
}
9799

98100
// Initialize read and write position of queue.
@@ -106,23 +108,23 @@ void CDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef *queue)
106108
// Reserve block in queue and return pointer to it.
107109
uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
108110
{
109-
const uint16_t limit =
110-
CDC_RECEIVE_QUEUE_BUFFER_SIZE - CDC_QUEUE_MAX_PACKET_SIZE;
111-
volatile uint16_t read = queue->read;
111+
const uint32_t limit =
112+
CDC_RECEIVE_QUEUE_BUFFER_SIZE - CDC_RECEIVE_MAX_BUFFER_SIZE;
113+
volatile uint32_t read = queue->read;
112114

113115
if (read <= queue->write) {
114116
// if write is limited only by buffer size.
115117
if (queue->write < limit || (queue->write == limit && read > 0)) {
116118
// if size in the rest of buffer is enough for full packet plus 1 byte
117119
// or if it tight enough and write position can be set to 0
118120
return queue->buffer + queue->write;
119-
} else if (read > CDC_QUEUE_MAX_PACKET_SIZE) {
121+
} else if (read > CDC_RECEIVE_MAX_BUFFER_SIZE) {
120122
// if size in the rest is not enough, but enough size in head
121123
queue->length = queue->write;
122124
queue->write = 0;
123125
return queue->buffer + queue->write;
124126
}
125-
} else if (queue->write + CDC_QUEUE_MAX_PACKET_SIZE < read) {
127+
} else if (queue->write + CDC_RECEIVE_MAX_BUFFER_SIZE < read) {
126128
// write position must be less than read position
127129
// after reading largest possible packet
128130
return queue->buffer + queue->write;
@@ -132,7 +134,7 @@ uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
132134

133135
// Commits block in queue and make it available for reading
134136
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue,
135-
uint16_t size)
137+
uint32_t size)
136138
{
137139
queue->write += size;
138140
if (queue->write >= queue->length) {
@@ -148,8 +150,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
148150
{
149151
// reading length after write make guarantee, that length >= write
150152
// and determined reading size will be smaller or equal than real one.
151-
volatile uint16_t write = queue->write;
152-
volatile uint16_t length = queue->length;
153+
volatile uint32_t write = queue->write;
154+
volatile uint32_t length = queue->length;
153155
if (write >= queue->read) {
154156
return write - queue->read;
155157
}
@@ -159,8 +161,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
159161
// Read one byte from queue.
160162
int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
161163
{
162-
volatile uint16_t write = queue->write;
163-
volatile uint16_t length = queue->length;
164+
volatile uint32_t write = queue->write;
165+
volatile uint32_t length = queue->length;
164166
if (queue->read == length) {
165167
queue->read = 0;
166168
}
@@ -177,8 +179,8 @@ int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
177179
// Peek byte from queue.
178180
int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
179181
{
180-
volatile uint16_t write = queue->write;
181-
volatile uint16_t length = queue->length;
182+
volatile uint32_t write = queue->write;
183+
volatile uint32_t length = queue->length;
182184
if (queue->read >= length) {
183185
queue->read = 0;
184186
}
@@ -188,12 +190,12 @@ int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
188190
return queue->buffer[queue->read];
189191
}
190192

191-
uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
192-
uint8_t *buffer, uint16_t size)
193+
uint32_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
194+
uint8_t *buffer, uint32_t size)
193195
{
194-
volatile uint16_t write = queue->write;
195-
volatile uint16_t length = queue->length;
196-
uint16_t available;
196+
volatile uint32_t write = queue->write;
197+
volatile uint32_t length = queue->length;
198+
uint32_t available;
197199

198200
if (queue->read >= length) {
199201
queue->read = 0;
@@ -216,11 +218,11 @@ uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
216218
}
217219

218220
bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
219-
uint8_t terminator, uint8_t *buffer, uint16_t size, uint16_t *fetched)
221+
uint8_t terminator, uint8_t *buffer, uint32_t size, uint32_t *fetched)
220222
{
221-
volatile uint16_t write = queue->write;
222-
volatile uint16_t length = queue->length;
223-
uint16_t available;
223+
volatile uint32_t write = queue->write;
224+
volatile uint32_t length = queue->length;
225+
uint32_t available;
224226

225227
if (queue->read >= length) {
226228
queue->read = 0;
@@ -235,10 +237,10 @@ bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
235237
}
236238

237239
uint8_t *start = &queue->buffer[queue->read];
238-
for (uint16_t i = 0; i < size; i++) {
240+
for (uint32_t i = 0; i < size; i++) {
239241
uint8_t ch = start[i];
240242
if (ch == terminator) {
241-
queue->read += (uint16_t)(i + 1);
243+
queue->read += (uint32_t)(i + 1);
242244
if (queue->read >= length) {
243245
queue->read = 0;
244246
}

‎libraries/USBDevice/src/cdc/usbd_cdc_if.c‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -238,7 +238,7 @@ static int8_t USBD_CDC_Receive(uint8_t *Buf, uint32_t *Len)
238238
UNUSED(Buf);
239239
#endif
240240
/* It always contains required amount of free space for writing */
241-
CDC_ReceiveQueue_CommitBlock(&ReceiveQueue, (uint16_t)(*Len));
241+
CDC_ReceiveQueue_CommitBlock(&ReceiveQueue, *Len);
242242
receivePended = false;
243243
/* If enough space in the queue for a full buffer then continue receive */
244244
if (!CDC_resume_receive()) {
@@ -330,7 +330,7 @@ bool CDC_connected()
330330

331331
void CDC_continue_transmit(void)
332332
{
333-
uint16_t size;
333+
uint32_t size;
334334
uint8_t *buffer;
335335
USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *) hUSBD_Device_CDC.pClassData;
336336
/*

0 commit comments

Comments
 (0)