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 835c80a

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 3250030 commit 835c80a
Copy full SHA for 835c80a

File tree

4 files changed

+54
-49
lines changed
Filter options

4 files changed

+54
-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+
size_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
+32-31Lines changed: 32 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -67,32 +67,33 @@ 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+
8890
queue->reserved = *size;
8991
return &queue->buffer[queue->read];
9092
}
9193

9294
void CDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef *queue)
9395
{
94-
queue->read = (queue->read + queue->reserved) %
95-
CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
96+
queue->read = (queue->read + queue->reserved) % CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
9697
}
9798

9899
// Initialize read and write position of queue.
@@ -106,23 +107,23 @@ void CDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef *queue)
106107
// Reserve block in queue and return pointer to it.
107108
uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
108109
{
109-
const uint16_t limit =
110-
CDC_RECEIVE_QUEUE_BUFFER_SIZE - CDC_QUEUE_MAX_PACKET_SIZE;
111-
volatile uint16_t read = queue->read;
110+
const uint32_t limit =
111+
CDC_RECEIVE_QUEUE_BUFFER_SIZE - CDC_RECEIVE_MAX_BUFFER_SIZE;
112+
volatile uint32_t read = queue->read;
112113

113114
if (read <= queue->write) {
114115
// if write is limited only by buffer size.
115116
if (queue->write < limit || (queue->write == limit && read > 0)) {
116117
// if size in the rest of buffer is enough for full packet plus 1 byte
117118
// or if it tight enough and write position can be set to 0
118119
return queue->buffer + queue->write;
119-
} else if (read > CDC_QUEUE_MAX_PACKET_SIZE) {
120+
} else if (read > CDC_RECEIVE_MAX_BUFFER_SIZE) {
120121
// if size in the rest is not enough, but enough size in head
121122
queue->length = queue->write;
122123
queue->write = 0;
123124
return queue->buffer + queue->write;
124125
}
125-
} else if (queue->write + CDC_QUEUE_MAX_PACKET_SIZE < read) {
126+
} else if (queue->write + CDC_RECEIVE_MAX_BUFFER_SIZE < read) {
126127
// write position must be less than read position
127128
// after reading largest possible packet
128129
return queue->buffer + queue->write;
@@ -132,7 +133,7 @@ uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
132133

133134
// Commits block in queue and make it available for reading
134135
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue,
135-
uint16_t size)
136+
uint32_t size)
136137
{
137138
queue->write += size;
138139
if (queue->write >= queue->length) {
@@ -148,8 +149,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
148149
{
149150
// reading length after write make guarantee, that length >= write
150151
// 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;
152+
volatile uint32_t write = queue->write;
153+
volatile uint32_t length = queue->length;
153154
if (write >= queue->read) {
154155
return write - queue->read;
155156
}
@@ -159,8 +160,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
159160
// Read one byte from queue.
160161
int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
161162
{
162-
volatile uint16_t write = queue->write;
163-
volatile uint16_t length = queue->length;
163+
volatile uint32_t write = queue->write;
164+
volatile uint32_t length = queue->length;
164165
if (queue->read == length) {
165166
queue->read = 0;
166167
}
@@ -177,8 +178,8 @@ int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
177178
// Peek byte from queue.
178179
int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
179180
{
180-
volatile uint16_t write = queue->write;
181-
volatile uint16_t length = queue->length;
181+
volatile uint32_t write = queue->write;
182+
volatile uint32_t length = queue->length;
182183
if (queue->read >= length) {
183184
queue->read = 0;
184185
}
@@ -188,12 +189,12 @@ int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
188189
return queue->buffer[queue->read];
189190
}
190191

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

198199
if (queue->read >= length) {
199200
queue->read = 0;
@@ -216,11 +217,11 @@ uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
216217
}
217218

218219
bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
219-
uint8_t terminator, uint8_t *buffer, uint16_t size, uint16_t *fetched)
220+
uint8_t terminator, uint8_t *buffer, uint32_t size, uint32_t *fetched)
220221
{
221-
volatile uint16_t write = queue->write;
222-
volatile uint16_t length = queue->length;
223-
uint16_t available;
222+
volatile uint32_t write = queue->write;
223+
volatile uint32_t length = queue->length;
224+
uint32_t available;
224225

225226
if (queue->read >= length) {
226227
queue->read = 0;
@@ -235,10 +236,10 @@ bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
235236
}
236237

237238
uint8_t *start = &queue->buffer[queue->read];
238-
for (uint16_t i = 0; i < size; i++) {
239+
for (uint32_t i = 0; i < size; i++) {
239240
uint8_t ch = start[i];
240241
if (ch == terminator) {
241-
queue->read += (uint16_t)(i + 1);
242+
queue->read += (uint32_t)(i + 1);
242243
if (queue->read >= length) {
243244
queue->read = 0;
244245
}

‎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.