Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit 66c8c0a

Browse filesBrowse 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 <luoshumymail@gmail.com>
1 parent 021d321 commit 66c8c0a
Copy full SHA for 66c8c0a

File tree

4 files changed

+55
-49
lines changed
Filter options

4 files changed

+55
-49
lines changed

‎libraries/USBDevice/inc/cdc_queue.h

Copy file name to clipboardExpand all lines: libraries/USBDevice/inc/cdc_queue.h
+16-12Lines 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

Copy file name to clipboardExpand all lines: libraries/USBDevice/src/USBSerial.cpp
+4-4Lines 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

Copy file name to clipboardExpand all lines: libraries/USBDevice/src/cdc/cdc_queue.c
+33-31Lines 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

Copy file name to clipboardExpand all lines: libraries/USBDevice/src/cdc/usbd_cdc_if.c
+2-2Lines 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 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.