18 |
19 |
20 |
21 |
22 | ESP Monitor
23 |
24 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_external_flash/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_external_flash/flash_config.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2022 Ha Thach (tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef FLASH_CONFIG_H_
26 | #define FLASH_CONFIG_H_
27 |
28 | // Un-comment to run example with custom SPI and SS e.g with FRAM breakout
29 | // #define CUSTOM_CS A5
30 | // #define CUSTOM_SPI SPI
31 |
32 | #if defined(CUSTOM_CS) && defined(CUSTOM_SPI)
33 | Adafruit_FlashTransport_SPI flashTransport(CUSTOM_CS, CUSTOM_SPI);
34 |
35 | #elif defined(ARDUINO_ARCH_ESP32)
36 |
37 | // ESP32 use same flash device that store code for file system.
38 | // SPIFlash will parse partition.cvs to detect FATFS partition to use
39 | Adafruit_FlashTransport_ESP32 flashTransport;
40 |
41 | #elif defined(ARDUINO_ARCH_RP2040)
42 |
43 | // RP2040 use same flash device that store code for file system. Therefore we
44 | // only need to specify start address and size (no need SPI or SS)
45 | // By default (start=0, size=0), values that match file system setting in
46 | // 'Tools->Flash Size' menu selection will be used.
47 | Adafruit_FlashTransport_RP2040 flashTransport;
48 |
49 | // To be compatible with CircuitPython partition scheme (start_address = 1 MB,
50 | // size = total flash - 1 MB) use const value (CPY_START_ADDR, CPY_SIZE) or
51 | // subclass Adafruit_FlashTransport_RP2040_CPY. Un-comment either of the
52 | // following line:
53 | // Adafruit_FlashTransport_RP2040
54 | // flashTransport(Adafruit_FlashTransport_RP2040::CPY_START_ADDR,
55 | // Adafruit_FlashTransport_RP2040::CPY_SIZE);
56 | // Adafruit_FlashTransport_RP2040_CPY flashTransport;
57 |
58 | #else
59 |
60 | // On-board external flash (QSPI or SPI) macros should already
61 | // defined in your board variant if supported
62 | // - EXTERNAL_FLASH_USE_QSPI
63 | // - EXTERNAL_FLASH_USE_CS/EXTERNAL_FLASH_USE_SPI
64 |
65 | #if defined(EXTERNAL_FLASH_USE_QSPI)
66 |
67 | Adafruit_FlashTransport_QSPI flashTransport;
68 |
69 | #elif defined(EXTERNAL_FLASH_USE_SPI)
70 |
71 | Adafruit_FlashTransport_SPI flashTransport(EXTERNAL_FLASH_USE_CS,
72 | EXTERNAL_FLASH_USE_SPI);
73 |
74 | #else
75 | #error No (Q)SPI flash are defined for your board !
76 | #endif
77 | #endif
78 |
79 | #endif
80 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_external_flash_sdcard/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_external_flash_sdcard/flash_config.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2022 Ha Thach (tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef FLASH_CONFIG_H_
26 | #define FLASH_CONFIG_H_
27 |
28 | // Un-comment to run example with custom SPI and SS e.g with FRAM breakout
29 | // #define CUSTOM_CS A5
30 | // #define CUSTOM_SPI SPI
31 |
32 | #if defined(CUSTOM_CS) && defined(CUSTOM_SPI)
33 | Adafruit_FlashTransport_SPI flashTransport(CUSTOM_CS, CUSTOM_SPI);
34 |
35 | #elif defined(ARDUINO_ARCH_ESP32)
36 |
37 | // ESP32 use same flash device that store code for file system.
38 | // SPIFlash will parse partition.cvs to detect FATFS partition to use
39 | Adafruit_FlashTransport_ESP32 flashTransport;
40 |
41 | #elif defined(ARDUINO_ARCH_RP2040)
42 |
43 | // RP2040 use same flash device that store code for file system. Therefore we
44 | // only need to specify start address and size (no need SPI or SS)
45 | // By default (start=0, size=0), values that match file system setting in
46 | // 'Tools->Flash Size' menu selection will be used.
47 | Adafruit_FlashTransport_RP2040 flashTransport;
48 |
49 | // To be compatible with CircuitPython partition scheme (start_address = 1 MB,
50 | // size = total flash - 1 MB) use const value (CPY_START_ADDR, CPY_SIZE) or
51 | // subclass Adafruit_FlashTransport_RP2040_CPY. Un-comment either of the
52 | // following line:
53 | // Adafruit_FlashTransport_RP2040
54 | // flashTransport(Adafruit_FlashTransport_RP2040::CPY_START_ADDR,
55 | // Adafruit_FlashTransport_RP2040::CPY_SIZE);
56 | // Adafruit_FlashTransport_RP2040_CPY flashTransport;
57 |
58 | #else
59 |
60 | // On-board external flash (QSPI or SPI) macros should already
61 | // defined in your board variant if supported
62 | // - EXTERNAL_FLASH_USE_QSPI
63 | // - EXTERNAL_FLASH_USE_CS/EXTERNAL_FLASH_USE_SPI
64 |
65 | #if defined(EXTERNAL_FLASH_USE_QSPI)
66 |
67 | Adafruit_FlashTransport_QSPI flashTransport;
68 |
69 | #elif defined(EXTERNAL_FLASH_USE_SPI)
70 |
71 | Adafruit_FlashTransport_SPI flashTransport(EXTERNAL_FLASH_USE_CS,
72 | EXTERNAL_FLASH_USE_SPI);
73 |
74 | #else
75 | #error No (Q)SPI flash are defined for your board !
76 | #endif
77 | #endif
78 |
79 | #endif
80 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_internal_flash_samd/.metro_m0_tinyusb.test.only:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pschatzmann/Adafruit_TinyUSB_Arduino/43ad4172584f6daca62557c0e012ca3047c6c546/examples/MassStorage/msc_internal_flash_samd/.metro_m0_tinyusb.test.only
--------------------------------------------------------------------------------
/examples/MassStorage/msc_ramdisk/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_ramdisk/msc_ramdisk.ino:
--------------------------------------------------------------------------------
1 | /*********************************************************************
2 | Adafruit invests time and resources providing this open source code,
3 | please support Adafruit and open-source hardware by purchasing
4 | products from Adafruit!
5 |
6 | MIT license, check LICENSE for more information
7 | Copyright (c) 2019 Ha Thach for Adafruit Industries
8 | All text above, and the splash screen below must be included in
9 | any redistribution
10 | *********************************************************************/
11 |
12 | #include "Adafruit_TinyUSB.h"
13 |
14 | // 8KB is the smallest size that windows allow to mount
15 | #define DISK_BLOCK_NUM 16
16 | #define DISK_BLOCK_SIZE 512
17 |
18 | #include "ramdisk.h"
19 |
20 | Adafruit_USBD_MSC usb_msc;
21 |
22 | // Eject button to demonstrate medium is not ready e.g SDCard is not present
23 | // whenever this button is pressed and hold, it will report to host as not ready
24 | #if defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS) || defined(ARDUINO_NRF52840_CIRCUITPLAY)
25 | #define BTN_EJECT 4 // Left Button
26 | bool activeState = true;
27 |
28 | #elif defined(ARDUINO_FUNHOUSE_ESP32S2)
29 | #define BTN_EJECT BUTTON_DOWN
30 | bool activeState = true;
31 |
32 | #elif defined PIN_BUTTON1
33 | #define BTN_EJECT PIN_BUTTON1
34 | bool activeState = false;
35 | #endif
36 |
37 |
38 | // the setup function runs once when you press reset or power the board
39 | void setup() {
40 | // Manual begin() is required on core without built-in support e.g. mbed rp2040
41 | if (!TinyUSBDevice.isInitialized()) {
42 | TinyUSBDevice.begin(0);
43 | }
44 |
45 | Serial.begin(115200);
46 |
47 | #ifdef BTN_EJECT
48 | pinMode(BTN_EJECT, activeState ? INPUT_PULLDOWN : INPUT_PULLUP);
49 | #endif
50 |
51 | // Set disk vendor id, product id and revision with string up to 8, 16, 4 characters respectively
52 | usb_msc.setID("Adafruit", "Mass Storage", "1.0");
53 |
54 | // Set disk size
55 | usb_msc.setCapacity(DISK_BLOCK_NUM, DISK_BLOCK_SIZE);
56 |
57 | // Set callback
58 | usb_msc.setReadWriteCallback(msc_read_callback, msc_write_callback, msc_flush_callback);
59 | usb_msc.setStartStopCallback(msc_start_stop_callback);
60 | usb_msc.setReadyCallback(msc_ready_callback);
61 |
62 | // Set Lun ready (RAM disk is always ready)
63 | usb_msc.setUnitReady(true);
64 | usb_msc.begin();
65 |
66 | // If already enumerated, additional class driverr begin() e.g msc, hid, midi won't take effect until re-enumeration
67 | if (TinyUSBDevice.mounted()) {
68 | TinyUSBDevice.detach();
69 | delay(10);
70 | TinyUSBDevice.attach();
71 | }
72 |
73 | // while ( !Serial ) delay(10); // wait for native usb
74 | Serial.println("Adafruit TinyUSB Mass Storage RAM Disk example");
75 | }
76 |
77 | void loop() {
78 | #ifdef TINYUSB_NEED_POLLING_TASK
79 | // Manual call tud_task since it isn't called by Core's background
80 | TinyUSBDevice.task();
81 | #endif
82 | }
83 |
84 | // Callback invoked when received READ10 command.
85 | // Copy disk's data to buffer (up to bufsize) and
86 | // return number of copied bytes (must be multiple of block size)
87 | int32_t msc_read_callback(uint32_t lba, void* buffer, uint32_t bufsize) {
88 | uint8_t const* addr = msc_disk[lba];
89 | memcpy(buffer, addr, bufsize);
90 |
91 | return bufsize;
92 | }
93 |
94 | // Callback invoked when received WRITE10 command.
95 | // Process data in buffer to disk's storage and
96 | // return number of written bytes (must be multiple of block size)
97 | int32_t msc_write_callback(uint32_t lba, uint8_t* buffer, uint32_t bufsize) {
98 | uint8_t* addr = msc_disk[lba];
99 | memcpy(addr, buffer, bufsize);
100 |
101 | return bufsize;
102 | }
103 |
104 | // Callback invoked when WRITE10 command is completed (status received and accepted by host).
105 | // used to flush any pending cache.
106 | void msc_flush_callback(void) {
107 | // nothing to do
108 | }
109 |
110 | bool msc_start_stop_callback(uint8_t power_condition, bool start, bool load_eject) {
111 | Serial.printf("Start/Stop callback: power condition %u, start %u, load_eject %u\n", power_condition, start, load_eject);
112 | return true;
113 | }
114 |
115 | // Invoked when received Test Unit Ready command.
116 | // return true allowing host to read/write this LUN e.g SD card inserted
117 | bool msc_ready_callback(void) {
118 | #ifdef BTN_EJECT
119 | // button not active --> medium ready
120 | return digitalRead(BTN_EJECT) != activeState;
121 | #else
122 | return true;
123 | #endif
124 | }
125 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_ramdisk_dual/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_ramdisk_dual/msc_ramdisk_dual.ino:
--------------------------------------------------------------------------------
1 | /*********************************************************************
2 | Adafruit invests time and resources providing this open source code,
3 | please support Adafruit and open-source hardware by purchasing
4 | products from Adafruit!
5 |
6 | MIT license, check LICENSE for more information
7 | Copyright (c) 2019 Ha Thach for Adafruit Industries
8 | All text above, and the splash screen below must be included in
9 | any redistribution
10 | *********************************************************************/
11 |
12 | #include "Adafruit_TinyUSB.h"
13 |
14 | // 8KB is the smallest size that windows allow to mount
15 | #define DISK_BLOCK_NUM 16
16 | #define DISK_BLOCK_SIZE 512
17 |
18 | #include "ramdisk.h"
19 |
20 | Adafruit_USBD_MSC usb_msc;
21 |
22 | // the setup function runs once when you press reset or power the board
23 | void setup() {
24 | // Manual begin() is required on core without built-in support e.g. mbed rp2040
25 | if (!TinyUSBDevice.isInitialized()) {
26 | TinyUSBDevice.begin(0);
27 | }
28 |
29 | Serial.begin(115200);
30 |
31 | usb_msc.setMaxLun(2);
32 |
33 | // Set disk size and callback for Logical Unit 0 (LUN 0)
34 | usb_msc.setID(0, "Adafruit", "Lun0", "1.0");
35 | usb_msc.setCapacity(0, DISK_BLOCK_NUM, DISK_BLOCK_SIZE);
36 | usb_msc.setReadWriteCallback(0, ram0_read_cb, ram0_write_cb, ram0_flush_cb);
37 | usb_msc.setUnitReady(0, true);
38 |
39 | // Set disk size and callback for Logical Unit 1 (LUN 1)
40 | usb_msc.setID(1, "Adafruit", "Lun1", "1.0");
41 | usb_msc.setCapacity(1, DISK_BLOCK_NUM, DISK_BLOCK_SIZE);
42 | usb_msc.setReadWriteCallback(1, ram1_read_cb, ram1_write_cb, ram1_flush_cb);
43 | usb_msc.setUnitReady(1, true);
44 |
45 | usb_msc.begin();
46 |
47 | // If already enumerated, additional class driverr begin() e.g msc, hid, midi won't take effect until re-enumeration
48 | if (TinyUSBDevice.mounted()) {
49 | TinyUSBDevice.detach();
50 | delay(10);
51 | TinyUSBDevice.attach();
52 | }
53 |
54 | //while ( !Serial ) delay(10); // wait for native usb
55 | Serial.println("Adafruit TinyUSB Mass Storage Dual RAM Disks example");
56 | }
57 |
58 | void loop() {
59 | #ifdef TINYUSB_NEED_POLLING_TASK
60 | // Manual call tud_task since it isn't called by Core's background
61 | TinyUSBDevice.task();
62 | #endif
63 | }
64 |
65 |
66 | //--------------------------------------------------------------------+
67 | // LUN 0 callback
68 | //--------------------------------------------------------------------+
69 |
70 | // Callback invoked when received READ10 command.
71 | // Copy disk's data to buffer (up to bufsize) and
72 | // return number of copied bytes (must be multiple of block size)
73 | int32_t ram0_read_cb(uint32_t lba, void* buffer, uint32_t bufsize) {
74 | uint8_t const* addr = msc_disk0[lba];
75 | memcpy(buffer, addr, bufsize);
76 |
77 | return bufsize;
78 | }
79 |
80 | // Callback invoked when received WRITE10 command.
81 | // Process data in buffer to disk's storage and
82 | // return number of written bytes (must be multiple of block size)
83 | int32_t ram0_write_cb(uint32_t lba, uint8_t* buffer, uint32_t bufsize) {
84 | uint8_t* addr = msc_disk0[lba];
85 | memcpy(addr, buffer, bufsize);
86 |
87 | return bufsize;
88 | }
89 |
90 | // Callback invoked when WRITE10 command is completed (status received and accepted by host).
91 | // used to flush any pending cache.
92 | void ram0_flush_cb(void) {
93 | // nothing to do
94 | }
95 |
96 |
97 | //--------------------------------------------------------------------+
98 | // LUN 1 callback
99 | //--------------------------------------------------------------------+
100 |
101 | // Callback invoked when received READ10 command.
102 | // Copy disk's data to buffer (up to bufsize) and
103 | // return number of copied bytes (must be multiple of block size)
104 | int32_t ram1_read_cb(uint32_t lba, void* buffer, uint32_t bufsize) {
105 | uint8_t const* addr = msc_disk1[lba];
106 | memcpy(buffer, addr, bufsize);
107 |
108 | return bufsize;
109 | }
110 |
111 | // Callback invoked when received WRITE10 command.
112 | // Process data in buffer to disk's storage and
113 | // return number of written bytes (must be multiple of block size)
114 | int32_t ram1_write_cb(uint32_t lba, uint8_t* buffer, uint32_t bufsize) {
115 | uint8_t* addr = msc_disk1[lba];
116 | memcpy(addr, buffer, bufsize);
117 |
118 | return bufsize;
119 | }
120 |
121 | // Callback invoked when WRITE10 command is completed (status received and accepted by host).
122 | // used to flush any pending cache.
123 | void ram1_flush_cb(void) {
124 | // nothing to do
125 | }
126 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_sd/.skip.txt:
--------------------------------------------------------------------------------
1 | feather_esp32s2
2 | feather_esp32s3
3 | funhouse
4 | magtag
5 | metroesp32s2
6 | feather_rp2040_tinyusb
7 | pico_rp2040_tinyusb_host
8 | CH32V20x_EVT
9 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_sd/msc_sd.ino:
--------------------------------------------------------------------------------
1 | /*********************************************************************
2 | Adafruit invests time and resources providing this open source code,
3 | please support Adafruit and open-source hardware by purchasing
4 | products from Adafruit!
5 |
6 | MIT license, check LICENSE for more information
7 | Copyright (c) 2019 Ha Thach for Adafruit Industries
8 | All text above, and the splash screen below must be included in
9 | any redistribution
10 | *********************************************************************/
11 |
12 | /* This example expose SD card as mass storage using
13 | * default SD Library
14 | */
15 |
16 | #include "SD.h"
17 | #include "Adafruit_TinyUSB.h"
18 |
19 | const int chipSelect = 10;
20 |
21 | Adafruit_USBD_MSC usb_msc;
22 |
23 | Sd2Card card;
24 | SdVolume volume;
25 |
26 | // the setup function runs once when you press reset or power the board
27 | void setup()
28 | {
29 | Serial.begin(115200);
30 |
31 | // Set disk vendor id, product id and revision with string up to 8, 16, 4 characters respectively
32 | usb_msc.setID("Adafruit", "SD Card", "1.0");
33 |
34 | // Set read write callback
35 | usb_msc.setReadWriteCallback(msc_read_cb, msc_write_cb, msc_flush_cb);
36 |
37 | // Still initialize MSC but tell usb stack that MSC is not ready to read/write
38 | // If we don't initialize, board will be enumerated as CDC only
39 | usb_msc.setUnitReady(false);
40 | usb_msc.begin();
41 |
42 | // If already enumerated, additional class driverr begin() e.g msc, hid, midi won't take effect until re-enumeration
43 | if (TinyUSBDevice.mounted()) {
44 | TinyUSBDevice.detach();
45 | delay(10);
46 | TinyUSBDevice.attach();
47 | }
48 |
49 | //while ( !Serial ) delay(10); // wait for native usb
50 | Serial.println("Adafruit TinyUSB Mass Storage SD Card example");
51 | Serial.println("\nInitializing SD card...");
52 |
53 | if ( !card.init(SPI_HALF_SPEED, chipSelect) ) {
54 | Serial.println("initialization failed. Things to check:");
55 | Serial.println("* is a card inserted?");
56 | Serial.println("* is your wiring correct?");
57 | Serial.println("* did you change the chipSelect pin to match your shield or module?");
58 | while (1) delay(1);
59 | }
60 |
61 | // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
62 | if (!volume.init(card)) {
63 | Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
64 | while (1) delay(1);
65 | }
66 |
67 | uint32_t block_count = volume.blocksPerCluster()*volume.clusterCount();
68 |
69 | Serial.print("Volume size (MB): ");
70 | Serial.println((block_count/2) / 1024);
71 |
72 | // Set disk size, SD block size is always 512
73 | usb_msc.setCapacity(block_count, 512);
74 |
75 | // MSC is ready for read/write
76 | usb_msc.setUnitReady(true);
77 | }
78 |
79 | void loop() {
80 | // nothing to do
81 | }
82 |
83 | // Callback invoked when received READ10 command.
84 | // Copy disk's data to buffer (up to bufsize) and
85 | // return number of copied bytes (must be multiple of block size)
86 | int32_t msc_read_cb (uint32_t lba, void* buffer, uint32_t bufsize) {
87 | (void) bufsize;
88 | return card.readBlock(lba, (uint8_t*) buffer) ? 512 : -1;
89 | }
90 |
91 | // Callback invoked when received WRITE10 command.
92 | // Process data in buffer to disk's storage and
93 | // return number of written bytes (must be multiple of block size)
94 | int32_t msc_write_cb (uint32_t lba, uint8_t* buffer, uint32_t bufsize) {
95 | (void) bufsize;
96 | return card.writeBlock(lba, buffer) ? 512 : -1;
97 | }
98 |
99 | // Callback invoked when WRITE10 command is completed (status received and accepted by host).
100 | // used to flush any pending cache.
101 | void msc_flush_cb (void) {
102 | // nothing to do
103 | }
104 |
--------------------------------------------------------------------------------
/examples/MassStorage/msc_sdfat/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 |
--------------------------------------------------------------------------------
/examples/Vendor/i2c_tiny_usb_adapter/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 |
--------------------------------------------------------------------------------
/examples/Vendor/i2c_tiny_usb_adapter/i2c_tiny_usb_adapter.ino:
--------------------------------------------------------------------------------
1 | /*********************************************************************
2 | Adafruit invests time and resources providing this open source code,
3 | please support Adafruit and open-source hardware by purchasing
4 | products from Adafruit!
5 |
6 | MIT license, check LICENSE for more information
7 | Copyright (c) 2019 Ha Thach for Adafruit Industries
8 | All text above, and the splash screen below must be included in
9 | any redistribution
10 | *********************************************************************/
11 |
12 | #include
13 | #include "Adafruit_TinyUSB.h"
14 |
15 | #include "Adafruit_USBD_I2C.h"
16 |
17 | /* This sketch demonstrates how to use tinyusb vendor interface to implement
18 | * i2c-tiny-usb adapter to use with Linux
19 | *
20 | * Reference:
21 | * - https://github.com/torvalds/linux/blob/master/drivers/i2c/busses/i2c-tiny-usb.c
22 | * - https://github.com/harbaum/I2C-Tiny-USB
23 | *
24 | * Requirement:
25 | * - Install i2c-tools with
26 | * sudo apt install i2c-tools
27 | *
28 | * How to test example:
29 | * - Compile and flash this sketch on your board with an i2c device, it should enumerated as
30 | * ID 1c40:0534 EZPrototypes i2c-tiny-usb interface
31 | *
32 | * - Run "i2cdetect -l" to find our bus ID e.g
33 | * i2c-8 i2c i2c-tiny-usb at bus 003 device 039 I2C adapter
34 | *
35 | * - Run "i2cdetect -y 8" to scan for on-board device (8 is the above bus ID)
36 | * 0 1 2 3 4 5 6 7 8 9 a b c d e f
37 | 00: -- -- -- -- -- -- -- --
38 | 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
39 | 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40 | 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
41 | 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
42 | 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
43 | 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
44 | 70: -- -- -- -- -- -- -- 77
45 |
46 | - You can then interact with sensor using following commands:
47 | i2cget i2cset i2cdump i2ctransfer or using any driver/tools that work on i2c device.
48 |
49 | Adafruit CircuitPython library for PC
50 | - You can use run CircuitPython library with Extended Bus to read sensor data.
51 | - 'i2c_usb.py' is provided a sample script
52 | */
53 |
54 | static uint8_t i2c_buf[800];
55 |
56 | #define MyWire Wire
57 | //#define MyWire Wire1
58 |
59 | Adafruit_USBD_I2C i2c_usb(&MyWire);
60 |
61 | void setup() {
62 | Serial.begin(115200);
63 |
64 | // init i2c usb with buffer and size
65 | i2c_usb.begin(i2c_buf, sizeof(i2c_buf));
66 |
67 | // If already enumerated, additional class driverr begin() e.g msc, hid, midi won't take effect until re-enumeration
68 | if (TinyUSBDevice.mounted()) {
69 | TinyUSBDevice.detach();
70 | delay(10);
71 | TinyUSBDevice.attach();
72 | }
73 | }
74 |
75 | void loop() {
76 | }
77 |
78 |
79 | // callback from tinyusb
80 | bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const* request)
81 | {
82 | return i2c_usb.handleControlTransfer(rhport, stage, request);
83 | }
84 |
85 |
--------------------------------------------------------------------------------
/examples/Vendor/i2c_tiny_usb_adapter/i2c_usb.py:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env python3
2 | #
3 | # before running, install required libraries:
4 | # pip3 install adafruit-extended-bus
5 | # pip3 install adafruit-circuitpython-bme280
6 |
7 | import time
8 | import adafruit_extended_bus
9 | from adafruit_bme280 import basic as adafruit_bme280
10 |
11 | # Run "i2cdetect -l" to find your bus number
12 | i2c_usb = adafruit_extended_bus.ExtendedI2C(8)
13 | bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c_usb)
14 | while 1:
15 | print("\nTemperature: %0.1f C" % bme280.temperature)
16 | print("Humidity: %0.1f %%" % bme280.humidity)
17 | print("Pressure: %0.1f hPa" % bme280.pressure)
18 | time.sleep(1)
--------------------------------------------------------------------------------
/examples/Video/video_capture/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 |
--------------------------------------------------------------------------------
/examples/WebUSB/webusb_rgb/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 | # CH32V20x_EVT is not supported due to Adafruit_Neopixel
--------------------------------------------------------------------------------
/examples/WebUSB/webusb_serial/.skip.txt:
--------------------------------------------------------------------------------
1 | pico_rp2040_tinyusb_host
2 | CH32V20x_EVT
3 | # CH32V20x_EVT is not supported due to lacking of HardwareSerial::read(uint8_t [64], int)
--------------------------------------------------------------------------------
/examples/WebUSB/webusb_serial/webusb_serial.ino:
--------------------------------------------------------------------------------
1 | /*********************************************************************
2 | Adafruit invests time and resources providing this open source code,
3 | please support Adafruit and open-source hardware by purchasing
4 | products from Adafruit!
5 |
6 | MIT license, check LICENSE for more information
7 | Copyright (c) 2019 Ha Thach for Adafruit Industries
8 | All text above, and the splash screen below must be included in
9 | any redistribution
10 | *********************************************************************/
11 |
12 | /* This sketch demonstrates WebUSB as web serial with browser with WebUSB support (e.g Chrome).
13 | * After enumerated successfully, Browser will pop-up notification
14 | * with URL to landing page, click on it to test
15 | * - Click "Connect" and select device, When connected the on-board LED will litted up.
16 | * - Any charters received from either webusb/Serial will be echo back to webusb and Serial
17 | *
18 | * Note:
19 | * - The WebUSB landing page notification is currently disabled in Chrome
20 | * on Windows due to Chromium issue 656702 (https://crbug.com/656702). You have to
21 | * go to landing page (below) to test
22 | *
23 | * - On Windows 7 and prior: You need to use Zadig tool to manually bind the
24 | * WebUSB interface with the WinUSB driver for Chrome to access. From windows 8 and 10, this
25 | * is done automatically by firmware.
26 | */
27 |
28 | #include "Adafruit_TinyUSB.h"
29 |
30 | // USB WebUSB object
31 | Adafruit_USBD_WebUSB usb_web;
32 |
33 | // Landing Page: scheme (0: http, 1: https), url
34 | // Page source can be found at https://github.com/hathach/tinyusb-webusb-page/tree/main/webusb-serial
35 | WEBUSB_URL_DEF(landingPage, 1 /*https*/, "example.tinyusb.org/webusb-serial/index.html");
36 |
37 | int led_pin = LED_BUILTIN;
38 |
39 | // the setup function runs once when you press reset or power the board
40 | void setup() {
41 | // Manual begin() is required on core without built-in support e.g. mbed rp2040
42 | if (!TinyUSBDevice.isInitialized()) {
43 | TinyUSBDevice.begin(0);
44 | }
45 | Serial.begin(115200);
46 |
47 | pinMode(led_pin, OUTPUT);
48 | digitalWrite(led_pin, LOW);
49 |
50 | usb_web.setLandingPage(&landingPage);
51 | usb_web.setLineStateCallback(line_state_callback);
52 | //usb_web.setStringDescriptor("TinyUSB WebUSB");
53 | usb_web.begin();
54 |
55 | // If already enumerated, additional class driverr begin() e.g msc, hid, midi won't take effect until re-enumeration
56 | if (TinyUSBDevice.mounted()) {
57 | TinyUSBDevice.detach();
58 | delay(10);
59 | TinyUSBDevice.attach();
60 | }
61 |
62 | // wait until device mounted
63 | while (!TinyUSBDevice.mounted()) delay(1);
64 |
65 | Serial.println("TinyUSB WebUSB Serial example");
66 | }
67 |
68 | // function to echo to both Serial and WebUSB
69 | void echo_all(uint8_t buf[], uint32_t count) {
70 | if (usb_web.connected()) {
71 | usb_web.write(buf, count);
72 | usb_web.flush();
73 | }
74 |
75 | if (Serial) {
76 | for (uint32_t i = 0; i < count; i++) {
77 | Serial.write(buf[i]);
78 | if (buf[i] == '\r') Serial.write('\n');
79 | }
80 | Serial.flush();
81 | }
82 | }
83 |
84 | void loop() {
85 | #ifdef TINYUSB_NEED_POLLING_TASK
86 | // Manual call tud_task since it isn't called by Core's background
87 | TinyUSBDevice.task();
88 | #endif
89 |
90 | uint8_t buf[64];
91 | uint32_t count;
92 |
93 | // From Serial to both Serial & webUSB
94 | if (Serial.available()) {
95 | count = Serial.read(buf, 64);
96 | echo_all(buf, count);
97 | }
98 |
99 | // from WebUSB to both Serial & webUSB
100 | if (usb_web.available()) {
101 | count = usb_web.read(buf, 64);
102 | echo_all(buf, count);
103 | }
104 | }
105 |
106 | void line_state_callback(bool connected) {
107 | digitalWrite(led_pin, connected);
108 |
109 | if (connected) {
110 | usb_web.println("WebUSB interface connected !!");
111 | usb_web.flush();
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/library.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Adafruit TinyUSB Library",
3 | "keywords": "usb, arduino, tinyusb",
4 | "description": "Arduino library for TinyUSB",
5 | "version": "3.4.1",
6 | "repository": {
7 | "type": "git",
8 | "url": "https://github.com/adafruit/Adafruit_TinyUSB_Arduino.git"
9 | },
10 | "frameworks": "*",
11 | "platforms": "*",
12 | "build": {
13 | "libArchive": false,
14 | "flags": "-DUSE_TINYUSB"
15 | },
16 | "authors":
17 | [
18 | {
19 | "name": "Adafruit",
20 | "maintainer": true
21 | }
22 | ]
23 | }
--------------------------------------------------------------------------------
/library.properties:
--------------------------------------------------------------------------------
1 | name=Adafruit TinyUSB Library
2 | version=3.4.2
3 | author=Adafruit
4 | maintainer=Adafruit
5 | sentence=TinyUSB library for Arduino
6 | paragraph=Support nRF5x, SAMD21, SAMD51, RP2040, ESP32-S2/S3, CH32V
7 | category=Communication
8 | url=https://github.com/adafruit/Adafruit_TinyUSB_Arduino
9 | architectures=*
10 | includes=Adafruit_TinyUSB.h
11 | depends=Adafruit SPIFlash, MIDI Library, SdFat - Adafruit Fork
12 |
--------------------------------------------------------------------------------
/src/Adafruit_TinyUSB.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_TINYUSB_H_
26 | #define ADAFRUIT_TINYUSB_H_
27 |
28 | // ESP32 out-of-sync
29 | #ifdef ARDUINO_ARCH_ESP32
30 | #include "arduino/ports/esp32/tusb_config_esp32.h"
31 | #endif
32 |
33 | #include "tusb_option.h"
34 |
35 | // Device
36 | #if CFG_TUD_ENABLED
37 |
38 | #include "arduino/Adafruit_USBD_Device.h"
39 |
40 | #if CFG_TUD_CDC
41 | #include "arduino/Adafruit_USBD_CDC.h"
42 | #endif
43 |
44 | #if CFG_TUD_HID
45 | #include "arduino/hid/Adafruit_USBD_HID.h"
46 | #endif
47 |
48 | #if CFG_TUD_MIDI
49 | #include "arduino/midi/Adafruit_USBD_MIDI.h"
50 | #endif
51 |
52 | #if CFG_TUD_MSC
53 | #include "arduino/msc/Adafruit_USBD_MSC.h"
54 | #endif
55 |
56 | #if CFG_TUD_VENDOR
57 | #include "arduino/webusb/Adafruit_USBD_WebUSB.h"
58 | #endif
59 |
60 | #if CFG_TUD_VIDEO
61 | #include "arduino/video/Adafruit_USBD_Video.h"
62 | #endif
63 |
64 | // Initialize device hardware, stack, also Serial as CDC
65 | // Wrapper for TinyUSBDevice.begin(rhport)
66 | void TinyUSB_Device_Init(uint8_t rhport);
67 |
68 | #endif
69 |
70 | // Host
71 | #if CFG_TUH_ENABLED
72 |
73 | #include "arduino/Adafruit_USBH_Host.h"
74 |
75 | #if CFG_TUH_CDC
76 | #include "arduino/cdc/Adafruit_USBH_CDC.h"
77 | #endif
78 |
79 | #if CFG_TUH_MSC
80 | #include "arduino/msc/Adafruit_USBH_MSC.h"
81 | #endif
82 |
83 | #endif
84 |
85 | #endif /* ADAFRUIT_TINYUSB_H_ */
86 |
--------------------------------------------------------------------------------
/src/arduino/Adafruit_TinyUSB_API.cpp:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #include "tusb_option.h"
26 |
27 | #if CFG_TUD_ENABLED || CFG_TUH_ENABLED
28 |
29 | #include "Adafruit_TinyUSB.h"
30 | #include "Arduino.h"
31 |
32 | extern "C" {
33 |
34 | //--------------------------------------------------------------------+
35 | // Device
36 | //--------------------------------------------------------------------+
37 | #if CFG_TUD_ENABLED
38 | void TinyUSB_Device_Init(uint8_t rhport) {
39 | // Init USB Device controller and stack
40 | TinyUSBDevice.begin(rhport);
41 | }
42 |
43 | // RP2040 has its own implementation since it needs mutex for dual core
44 | #ifndef ARDUINO_ARCH_RP2040
45 | void TinyUSB_Device_Task(void) {
46 | // Run tinyusb device task
47 | tud_task();
48 | }
49 | #endif
50 |
51 | #ifndef ARDUINO_ARCH_ESP32
52 | void TinyUSB_Device_FlushCDC(void) {
53 | uint8_t const cdc_instance = Adafruit_USBD_CDC::getInstanceCount();
54 | for (uint8_t instance = 0; instance < cdc_instance; instance++) {
55 | tud_cdc_n_write_flush(instance);
56 | }
57 | }
58 | #endif
59 | #endif // CFG_TUD_ENABLED
60 |
61 | //------------- Debug log with Serial1 -------------//
62 | #if CFG_TUSB_DEBUG && defined(CFG_TUSB_DEBUG_PRINTF) && \
63 | !defined(ARDUINO_ARCH_ESP32)
64 |
65 | // #define USE_SEGGER_RTT
66 | #ifndef SERIAL_TUSB_DEBUG
67 | #define SERIAL_TUSB_DEBUG Serial1
68 | #endif
69 |
70 | #ifdef USE_SEGGER_RTT
71 | #include "SEGGER_RTT/RTT/SEGGER_RTT.h"
72 | #endif
73 |
74 | __attribute__((used)) int CFG_TUSB_DEBUG_PRINTF(const char *__restrict format,
75 | ...) {
76 | char buf[256];
77 | int len;
78 | va_list ap;
79 | va_start(ap, format);
80 | len = vsnprintf(buf, sizeof(buf), format, ap);
81 |
82 | #ifdef USE_SEGGER_RTT
83 | SEGGER_RTT_Write(0, buf, len);
84 | #else
85 | static volatile bool ser_inited = false;
86 | if (!ser_inited) {
87 | ser_inited = true;
88 | SERIAL_TUSB_DEBUG.begin(115200);
89 | // SERIAL_TUSB_DEBUG.begin(921600);
90 | }
91 | SERIAL_TUSB_DEBUG.write(buf);
92 | #endif
93 |
94 | va_end(ap);
95 | return len;
96 | }
97 | #endif // CFG_TUSB_DEBUG
98 |
99 | } // extern C
100 |
101 | #endif // CFG_TUD_ENABLED || CFG_TUH_ENABLED
102 |
--------------------------------------------------------------------------------
/src/arduino/Adafruit_TinyUSB_API.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_TINYUSB_API_H_
26 | #define ADAFRUIT_TINYUSB_API_H_
27 |
28 | #include
29 | #include
30 |
31 | // API Version, need to be updated when there is changes for
32 | // TinyUSB_API, USBD_CDC, USBD_Device, USBD_Interface,
33 | #define TINYUSB_API_VERSION 30000
34 |
35 | #if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_NRF52_ADAFRUIT) || \
36 | defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_CH32) || \
37 | (defined(ARDUINO_ARCH_RP2040) && !defined(ARDUINO_ARCH_MBED))
38 | #define TINYUSB_HAS_BUITLTIN_CORE_SUPPORT
39 | #endif
40 |
41 | // Core that has built-in support: Adafruit SAMD, Adafruit nRF, rp2040, esp32
42 | #if !defined(TINYUSB_HAS_BUITLTIN_CORE_SUPPORT)
43 | #define TINYUSB_NEED_POLLING_TASK
44 | #endif
45 |
46 | // Error message for Core that must select TinyUSB via menu (built-in except
47 | // esp32)
48 | #if !defined(USE_TINYUSB) && (defined(TINYUSB_HAS_BUITLTIN_CORE_SUPPORT) && \
49 | !defined(ARDUINO_ARCH_ESP32))
50 | #error TinyUSB is not selected, please select it in "Tools->Menu->USB Stack"
51 | #endif
52 |
53 | //--------------------------------------------------------------------+
54 | // Core API
55 | // Should be called by BSP Core to initialize, process task
56 | // Weak function allow compile arduino core before linking with this library
57 | //--------------------------------------------------------------------+
58 | #ifdef __cplusplus
59 | extern "C" {
60 | #endif
61 |
62 | // Called by core/sketch to initialize usb device hardware and stack
63 | // This also initialize Serial as CDC device
64 | void TinyUSB_Device_Init(uint8_t rhport) __attribute__((weak));
65 |
66 | // Called by core/sketch to handle device event
67 | void TinyUSB_Device_Task(void) __attribute__((weak));
68 |
69 | // Called by core/sketch to flush write on CDC
70 | void TinyUSB_Device_FlushCDC(void) __attribute__((weak));
71 |
72 | #ifdef __cplusplus
73 | }
74 | #endif
75 |
76 | //--------------------------------------------------------------------+
77 | // Port API
78 | // Must be implemented by each BSP core/platform
79 | //--------------------------------------------------------------------+
80 |
81 | // To enter/reboot to bootloader
82 | // usually when host disconnects cdc at baud 1200 (touch 1200)
83 | void TinyUSB_Port_EnterDFU(void);
84 |
85 | // Init device hardware.
86 | // Called by TinyUSB_Device_Init()
87 | void TinyUSB_Port_InitDevice(uint8_t rhport);
88 |
89 | // Get unique serial number, needed for Serial String Descriptor
90 | // Fill serial_id (raw bytes) and return its length (limit to 16 bytes)
91 | // Note: Serial descriptor can be overwritten by user API
92 | uint8_t TinyUSB_Port_GetSerialNumber(uint8_t serial_id[16]);
93 |
94 | #endif
95 |
--------------------------------------------------------------------------------
/src/arduino/Adafruit_USBD_CDC.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBD_CDC_H_
26 | #define ADAFRUIT_USBD_CDC_H_
27 |
28 | #include "Adafruit_TinyUSB_API.h"
29 |
30 | #if defined(__cplusplus)
31 |
32 | #if defined(ARDUINO_ARCH_ESP32)
33 |
34 | // For ESP32 use USBCDC as it is compatible
35 | #define Adafruit_USBD_CDC USBCDC
36 | #define SerialTinyUSB Serial
37 |
38 | #else
39 |
40 | #include "Adafruit_USBD_Interface.h"
41 | #include "Stream.h"
42 |
43 | class Adafruit_USBD_CDC : public Stream, public Adafruit_USBD_Interface {
44 | public:
45 | Adafruit_USBD_CDC(void);
46 |
47 | static uint8_t getInstanceCount(void) { return _instance_count; }
48 |
49 | void setPins(uint8_t pin_rx, uint8_t pin_tx) {
50 | (void)pin_rx;
51 | (void)pin_tx;
52 | }
53 | void begin(uint32_t baud);
54 | void begin(uint32_t baud, uint8_t config);
55 | void end(void);
56 |
57 | // return line coding set by host
58 | uint32_t baud(void);
59 | uint8_t stopbits(void);
60 | uint8_t paritytype(void);
61 | uint8_t numbits(void);
62 | int dtr(void);
63 |
64 | // Stream API
65 | virtual int available(void);
66 | virtual int peek(void);
67 |
68 | virtual int read(void);
69 | size_t read(uint8_t *buffer, size_t size);
70 |
71 | virtual void flush(void);
72 | virtual size_t write(uint8_t);
73 |
74 | virtual size_t write(const uint8_t *buffer, size_t size);
75 | size_t write(const char *buffer, size_t size) {
76 | return write((const uint8_t *)buffer, size);
77 | }
78 |
79 | virtual int availableForWrite(void);
80 | using Print::write; // pull in write(str) from Print
81 | operator bool();
82 |
83 | // from Adafruit_USBD_Interface
84 | virtual uint16_t getInterfaceDescriptor(uint8_t itfnum_deprecated,
85 | uint8_t *buf, uint16_t bufsize);
86 |
87 | private:
88 | enum { INVALID_INSTANCE = 0xffu };
89 | static uint8_t _instance_count;
90 |
91 | uint8_t _instance;
92 |
93 | bool isValid(void) { return _instance != INVALID_INSTANCE; }
94 | };
95 |
96 | extern Adafruit_USBD_CDC SerialTinyUSB;
97 |
98 | // Built-in support "Serial" is assigned to TinyUSB CDC
99 | // CH32 defines Serial as alias in WSerial.h
100 | #if defined(USE_TINYUSB) && !defined(ARDUINO_ARCH_CH32)
101 | #define SerialTinyUSB Serial
102 | #endif
103 |
104 | extern Adafruit_USBD_CDC SerialTinyUSB;
105 |
106 | #endif // else of ESP32
107 | #endif // __cplusplus
108 |
109 | #endif
110 |
--------------------------------------------------------------------------------
/src/arduino/Adafruit_USBD_Interface.cpp:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021 Ha Thach (tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #include "tusb_option.h"
26 |
27 | #if CFG_TUD_ENABLED
28 |
29 | #include "Adafruit_USBD_Device.h"
30 |
31 | void Adafruit_USBD_Interface::setStringDescriptor(const char *str) {
32 | _strid = TinyUSBDevice.addStringDescriptor(str);
33 | }
34 |
35 | #endif
--------------------------------------------------------------------------------
/src/arduino/Adafruit_USBD_Interface.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021 Ha Thach (tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBD_INTERFACE_H_
26 | #define ADAFRUIT_USBD_INTERFACE_H_
27 |
28 | #include
29 | #include
30 |
31 | #if defined(ARDUINO_ARCH_CH32) || defined(CH32V20x) || defined(CH32V30x)
32 | // HACK: required for ch32 core version 1.0.4 or prior, removed when 1.0.5 is
33 | // released
34 | extern "C" void yield(void);
35 | #endif
36 |
37 | class Adafruit_USBD_Interface {
38 | protected:
39 | uint8_t _strid;
40 |
41 | public:
42 | Adafruit_USBD_Interface(void) { _strid = 0; }
43 |
44 | // Get Interface Descriptor
45 | // Fill the descriptor (if buf is not NULL) and return its length
46 | virtual uint16_t getInterfaceDescriptor(uint8_t itfnum_deprecated,
47 | uint8_t *buf, uint16_t bufsize) = 0;
48 | // Get Interface Descriptor Length
49 | uint16_t getInterfaceDescriptorLen() {
50 | return getInterfaceDescriptor(0, NULL, 0);
51 | }
52 |
53 | void setStringDescriptor(const char *str);
54 | };
55 |
56 | #endif
57 |
--------------------------------------------------------------------------------
/src/arduino/Adafruit_USBH_Host.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBH_HOST_H_
26 | #define ADAFRUIT_USBH_HOST_H_
27 |
28 | #include "Adafruit_USBD_Interface.h"
29 | #include "tusb.h"
30 | #include
31 |
32 | #ifdef ARDUINO_ARCH_ESP32
33 | #include "esp32-hal-tinyusb.h"
34 | #endif
35 |
36 | #if defined(CFG_TUH_MAX3421) && CFG_TUH_MAX3421
37 | extern "C" {
38 | void tuh_max3421_spi_cs_api(uint8_t rhport, bool active);
39 | bool tuh_max3421_spi_xfer_api(uint8_t rhport, uint8_t const *tx_buf,
40 | uint8_t *rx_buf, size_t xfer_bytes);
41 | void tuh_max3421_int_api(uint8_t rhport, bool enabled);
42 | }
43 |
44 | class Adafruit_USBH_Host {
45 | private:
46 | SPIClass *_spi;
47 | int8_t _cs;
48 | int8_t _intr;
49 |
50 | // for esp32 or using softwareSPI
51 | int8_t _sck, _mosi, _miso;
52 |
53 | public:
54 | // constructor for using MAX3421E (host shield)
55 | Adafruit_USBH_Host(SPIClass *spi, int8_t cs, int8_t intr);
56 | Adafruit_USBH_Host(SPIClass *spi, int8_t sck, int8_t mosi, int8_t miso,
57 | int8_t cs, int8_t intr);
58 |
59 | uint8_t max3421_readRegister(uint8_t reg, bool in_isr);
60 | bool max3421_writeRegister(uint8_t reg, uint8_t data, bool in_isr);
61 | bool max3421_writeIOPINS1(uint8_t data, bool in_isr) {
62 | enum { IOPINS1_ADDR = 20u << 3 }; // 0xA0
63 | return max3421_writeRegister(IOPINS1_ADDR, data, in_isr);
64 | }
65 | bool max3421_writeIOPINS2(uint8_t data, bool in_isr) {
66 | enum { IOPINS2_ADDR = 21u << 3 }; // 0xA8
67 | return max3421_writeRegister(IOPINS2_ADDR, data, in_isr);
68 | }
69 |
70 | private:
71 | friend void tuh_max3421_spi_cs_api(uint8_t rhport, bool active);
72 | friend bool tuh_max3421_spi_xfer_api(uint8_t rhport, uint8_t const *tx_buf,
73 | uint8_t *rx_buf, size_t xfer_bytes);
74 | friend void tuh_max3421_int_api(uint8_t rhport, bool enabled);
75 | #else
76 |
77 | class Adafruit_USBH_Host {
78 | #endif
79 |
80 | public:
81 | // default constructor
82 | Adafruit_USBH_Host(void);
83 |
84 | bool configure(uint8_t rhport, uint32_t cfg_id, const void *cfg_param);
85 |
86 | #ifdef ARDUINO_ARCH_RP2040
87 | bool configure_pio_usb(uint8_t rhport, const void *cfg_param);
88 | #endif
89 |
90 | bool begin(uint8_t rhport);
91 | void task(uint32_t timeout_ms = UINT32_MAX, bool in_isr = false);
92 |
93 | //------------- internal usage -------------//
94 | static Adafruit_USBH_Host *_instance;
95 |
96 | private:
97 | uint8_t _rhport;
98 | };
99 |
100 | #endif
101 |
--------------------------------------------------------------------------------
/src/arduino/cdc/Adafruit_USBH_CDC.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2022 Ha Thach (tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBH_CDC_H_
26 | #define ADAFRUIT_USBH_CDC_H_
27 |
28 | #include "HardwareSerial.h"
29 |
30 | class Adafruit_USBH_CDC : public HardwareSerial {
31 | public:
32 | Adafruit_USBH_CDC(void);
33 |
34 | // Set/Get index of cdc interface
35 | void setInterfaceIndex(uint8_t idx) { _idx = idx; }
36 | uint8_t getInterfaceIndex(void) { return _idx; }
37 |
38 | void begin(unsigned long baudrate);
39 | void begin(unsigned long baudrate, uint16_t config);
40 |
41 | bool mount(uint8_t idx);
42 | void umount(uint8_t idx);
43 |
44 | // unbind cdc interface
45 | void end(void);
46 |
47 | // If cdc is mounted
48 | bool mounted(void);
49 | operator bool() { return mounted(); }
50 |
51 | // if cdc's DTR is asserted
52 | bool connected(void);
53 |
54 | // Line encoding
55 | uint32_t baud();
56 |
57 | //------------- Control API -------------//
58 | bool setDtrRts(bool dtr, bool rts, tuh_xfer_cb_t complete_cb = NULL,
59 | uintptr_t user_data = 0);
60 | bool setBaudrate(uint32_t baudrate, tuh_xfer_cb_t complete_cb = NULL,
61 | uintptr_t user_data = 0);
62 |
63 | //------------- Stream API -------------//
64 | virtual int available(void);
65 | virtual int peek(void);
66 |
67 | virtual int read(void);
68 | size_t read(uint8_t *buffer, size_t size);
69 |
70 | virtual void flush(void);
71 | virtual size_t write(uint8_t ch);
72 |
73 | virtual size_t write(const uint8_t *buffer, size_t size);
74 | size_t write(const char *buffer, size_t size) {
75 | return write((const uint8_t *)buffer, size);
76 | }
77 |
78 | virtual int availableForWrite(void);
79 | using Print::write; // pull in write(str) from Print
80 |
81 | private:
82 | uint8_t _idx; // TinyUSB CDC Interface Index
83 | uint32_t _baud;
84 | };
85 |
86 | #endif
87 |
--------------------------------------------------------------------------------
/src/arduino/midi/Adafruit_USBD_MIDI.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 hathach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBD_MIDI_H_
26 | #define ADAFRUIT_USBD_MIDI_H_
27 |
28 | #include "Stream.h"
29 | #include "arduino/Adafruit_USBD_Device.h"
30 |
31 | class Adafruit_USBD_MIDI : public Stream, public Adafruit_USBD_Interface {
32 | public:
33 | Adafruit_USBD_MIDI(uint8_t n_cables = 1);
34 |
35 | void setCables(uint8_t n_cables);
36 |
37 | // Set the cable number with a USB device descriptor string
38 | // Note: per MIDI specs cable_id (or jackid/elementid) starting from 1. 0 is
39 | // reserved for undefined ID.
40 | bool setCableName(uint8_t cable_id, const char *str);
41 | bool begin(void);
42 |
43 | // for MIDI library
44 | bool begin(uint32_t baud) {
45 | (void)baud;
46 | return begin();
47 | }
48 |
49 | // Stream interface to use with MIDI Library
50 | virtual int read(void);
51 | virtual size_t write(uint8_t b);
52 | virtual int available(void);
53 | virtual int peek(void);
54 | virtual void flush(void);
55 |
56 | using Stream::write;
57 |
58 | // Raw MIDI USB packet interface.
59 | bool writePacket(const uint8_t packet[4]);
60 | bool readPacket(uint8_t packet[4]);
61 |
62 | // from Adafruit_USBD_Interface
63 | virtual uint16_t getInterfaceDescriptor(uint8_t itfnum_deprecated,
64 | uint8_t *buf, uint16_t bufsize);
65 |
66 | private:
67 | uint8_t _n_cables;
68 | uint8_t _cable_name_strid[16];
69 | };
70 |
71 | #endif /* ADAFRUIT_USBD_MIDI_H_ */
72 |
--------------------------------------------------------------------------------
/src/arduino/msc/Adafruit_USBH_MSC.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2022 Ha Thach (tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBH_MSC_H_
26 | #define ADAFRUIT_USBH_MSC_H_
27 |
28 | #include "tusb.h"
29 |
30 | // define SdFat host helper class if SdFat library is available
31 | #if __has_include("SdFat.h")
32 |
33 | #include "SdFat.h"
34 |
35 | class Adafruit_USBH_MSC_BlockDevice : public FsBlockDeviceInterface {
36 | public:
37 | Adafruit_USBH_MSC_BlockDevice();
38 |
39 | bool begin(uint8_t dev_addr);
40 | void end(void);
41 |
42 | bool mounted(void);
43 |
44 | // Set active LUN
45 | bool setActiveLUN(uint8_t lun);
46 | void setWriteCompleteCallback(tuh_msc_complete_cb_t cb);
47 |
48 | //------------- SdFat v2 FsBlockDeviceInterface API -------------//
49 | virtual bool isBusy();
50 | virtual uint32_t sectorCount();
51 | virtual bool syncDevice();
52 |
53 | virtual bool readSector(uint32_t block, uint8_t *dst);
54 | virtual bool readSectors(uint32_t block, uint8_t *dst, size_t ns);
55 | virtual bool writeSector(uint32_t block, const uint8_t *src);
56 | virtual bool writeSectors(uint32_t block, const uint8_t *src, size_t ns);
57 |
58 | //------------- Internal APIs -------------//
59 | bool _io_complete_cb(uint8_t dev_addr,
60 | tuh_msc_complete_data_t const *cb_data);
61 |
62 | private:
63 | uint8_t _daddr;
64 | uint8_t _lun;
65 |
66 | // TODO use mutex to prevent race condition or atomic for better
67 | // implementation
68 | volatile bool _busy;
69 |
70 | tuh_msc_complete_cb_t _wr_cb;
71 |
72 | bool wait_for_io(void);
73 | };
74 |
75 | #endif
76 |
77 | #endif
78 |
--------------------------------------------------------------------------------
/src/arduino/video/Adafruit_USBD_Video.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2024 Ha Thach (tinyusb.org)
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 | #ifndef ADAFRUIT_USBD_VIDEO_H
28 | #define ADAFRUIT_USBD_VIDEO_H
29 |
30 | #include "arduino/Adafruit_USBD_Device.h"
31 |
32 | class Adafruit_USBD_Video : public Adafruit_USBD_Interface {
33 | public:
34 | Adafruit_USBD_Video(void);
35 |
36 | bool begin();
37 |
38 | //------------- Video Control -------------//
39 | // bool isStreaming(uint8_t stream_idx);
40 | bool
41 | addTerminal(tusb_desc_video_control_camera_terminal_t const *camera_terminal);
42 | bool
43 | addTerminal(tusb_desc_video_control_output_terminal_t const *output_terminal);
44 |
45 | //------------- Video Streaming -------------//
46 | // bool setIsochronousStreaming(bool enabled);
47 |
48 | // Add format descriptor, return format index
49 | bool addFormat(tusb_desc_video_format_uncompressed_t const *format);
50 | bool addFrame(tusb_desc_video_frame_uncompressed_continuous_t const *frame);
51 | void
52 | addColorMatching(tusb_desc_video_streaming_color_matching_t const *color);
53 |
54 | // from Adafruit_USBD_Interface
55 | virtual uint16_t getInterfaceDescriptor(uint8_t itfnum_deprecated,
56 | uint8_t *buf, uint16_t bufsize);
57 |
58 | private:
59 | uint8_t _vc_id;
60 |
61 | tusb_desc_video_control_camera_terminal_t _camera_terminal;
62 | tusb_desc_video_control_output_terminal_t _output_terminal;
63 |
64 | // currently only support 1 format
65 | union {
66 | tusb_desc_video_format_uncompressed_t uncompressed;
67 | tusb_desc_video_format_mjpeg_t mjpeg;
68 | } _format;
69 |
70 | union {
71 | tusb_desc_video_frame_uncompressed_continuous_t uncompressed_cont;
72 | tusb_desc_video_frame_mjpeg_continuous_t mjpeg;
73 | } _frame;
74 |
75 | tusb_desc_video_streaming_color_matching_t _color_matching;
76 | };
77 |
78 | #endif
79 |
--------------------------------------------------------------------------------
/src/arduino/webusb/Adafruit_USBD_WebUSB.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 hathach for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef ADAFRUIT_USBD_WEBUSB_H_
26 | #define ADAFRUIT_USBD_WEBUSB_H_
27 |
28 | #include "Stream.h"
29 | #include "arduino/Adafruit_USBD_Device.h"
30 |
31 | #define WEBUSB_URL_DEF(_name, _scheme, _url) \
32 | struct TU_ATTR_PACKED { \
33 | uint8_t bLength; \
34 | uint8_t bDescriptorType; \
35 | uint8_t bScheme; \
36 | char url[3 + sizeof(_url)]; \
37 | } const _name = {3 + sizeof(_url) - 1, 3, _scheme, _url}
38 |
39 | class Adafruit_USBD_WebUSB : public Stream, public Adafruit_USBD_Interface {
40 | public:
41 | typedef void (*linestate_callback_t)(bool connected);
42 | Adafruit_USBD_WebUSB(const void *url = NULL);
43 |
44 | bool begin(void);
45 |
46 | bool setLandingPage(const void *url);
47 | void setLineStateCallback(linestate_callback_t fp);
48 |
49 | // Stream API
50 | virtual int available(void);
51 | virtual int peek(void);
52 |
53 | virtual int read(void);
54 | size_t read(uint8_t *buffer, size_t size);
55 |
56 | virtual void flush(void);
57 | virtual size_t write(uint8_t b);
58 |
59 | virtual size_t write(const uint8_t *buffer, size_t size);
60 | size_t write(const char *buffer, size_t size) {
61 | return write((const uint8_t *)buffer, size);
62 | }
63 |
64 | bool connected(void);
65 | operator bool();
66 |
67 | // from Adafruit_USBD_Interface
68 | virtual uint16_t getInterfaceDescriptor(uint8_t itfnum_deprecated,
69 | uint8_t *buf, uint16_t bufsize);
70 |
71 | private:
72 | bool _connected;
73 | const uint8_t *_url;
74 | linestate_callback_t _linestate_cb;
75 |
76 | // Make all tinyusb callback friend to access private data
77 | friend bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage,
78 | tusb_control_request_t const *request);
79 | };
80 |
81 | #endif /* ADAFRUIT_USBD_WEBUSB_H_ */
82 |
--------------------------------------------------------------------------------
/src/class/cdc/serial/ch34x.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2023 Heiko Kuester
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 | #ifndef _CH34X_H_
28 | #define _CH34X_H_
29 |
30 | // There is no official documentation for the CH34x (CH340, CH341) chips. Reference can be found
31 | // - https://github.com/WCHSoftGroup/ch341ser_linux
32 | // - https://github.com/torvalds/linux/blob/master/drivers/usb/serial/ch341.c
33 | // - https://github.com/freebsd/freebsd-src/blob/main/sys/dev/usb/serial/uchcom.c
34 |
35 | // set line_coding @ enumeration
36 | #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
37 | #define CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X CFG_TUH_CDC_LINE_CODING_ON_ENUM
38 | #else // this default is necessary to work properly
39 | #define CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X { 9600, CDC_LINE_CONDING_STOP_BITS_1, CDC_LINE_CODING_PARITY_NONE, 8 }
40 | #endif
41 |
42 | // USB requests
43 | #define CH34X_REQ_READ_VERSION 0x5F // dec 95
44 | #define CH34X_REQ_WRITE_REG 0x9A // dec 154
45 | #define CH34X_REQ_READ_REG 0x95 // dec 149
46 | #define CH34X_REQ_SERIAL_INIT 0xA1 // dec 161
47 | #define CH34X_REQ_MODEM_CTRL 0xA4 // dev 164
48 |
49 | // registers
50 | #define CH34X_REG_BREAK 0x05
51 | #define CH34X_REG_PRESCALER 0x12
52 | #define CH34X_REG_DIVISOR 0x13
53 | #define CH34X_REG_LCR 0x18
54 | #define CH34X_REG_LCR2 0x25
55 | #define CH34X_REG_MCR_MSR 0x06
56 | #define CH34X_REG_MCR_MSR2 0x07
57 | #define CH34X_NBREAK_BITS 0x01
58 |
59 | #define CH341_REG_0x0F 0x0F // undocumented register
60 | #define CH341_REG_0x2C 0x2C // undocumented register
61 | #define CH341_REG_0x27 0x27 // hardware flow control (cts/rts)
62 |
63 | #define CH34X_REG16_DIVISOR_PRESCALER TU_U16(CH34X_REG_DIVISOR, CH34X_REG_PRESCALER)
64 | #define CH32X_REG16_LCR2_LCR TU_U16(CH34X_REG_LCR2, CH34X_REG_LCR)
65 |
66 | // modem control bits
67 | #define CH34X_BIT_RTS ( 1 << 6 )
68 | #define CH34X_BIT_DTR ( 1 << 5 )
69 |
70 | // line control bits
71 | #define CH34X_LCR_ENABLE_RX 0x80
72 | #define CH34X_LCR_ENABLE_TX 0x40
73 | #define CH34X_LCR_MARK_SPACE 0x20
74 | #define CH34X_LCR_PAR_EVEN 0x10
75 | #define CH34X_LCR_ENABLE_PAR 0x08
76 | #define CH34X_LCR_PAR_MASK 0x38 // all parity bits
77 | #define CH34X_LCR_STOP_BITS_2 0x04
78 | #define CH34X_LCR_CS8 0x03
79 | #define CH34X_LCR_CS7 0x02
80 | #define CH34X_LCR_CS6 0x01
81 | #define CH34X_LCR_CS5 0x00
82 | #define CH34X_LCR_CS_MASK 0x03 // all CSx bits
83 |
84 | #endif /* _CH34X_H_ */
85 |
--------------------------------------------------------------------------------
/src/class/cdc/serial/cp210x.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2023 Ha Thach (thach@tinyusb.org) for Adafruit Industries
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef TUSB_CP210X_H
26 | #define TUSB_CP210X_H
27 |
28 | // Protocol details can be found at AN571: CP210x Virtual COM Port Interface
29 | // https://www.silabs.com/documents/public/application-notes/AN571.pdf
30 |
31 | #define TU_CP210X_VID 0x10C4
32 |
33 | /* Config request codes */
34 | #define CP210X_IFC_ENABLE 0x00
35 | #define CP210X_SET_BAUDDIV 0x01
36 | #define CP210X_GET_BAUDDIV 0x02
37 | #define CP210X_SET_LINE_CTL 0x03 // Set parity, data bits, stop bits
38 | #define CP210X_GET_LINE_CTL 0x04
39 | #define CP210X_SET_BREAK 0x05
40 | #define CP210X_IMM_CHAR 0x06
41 | #define CP210X_SET_MHS 0x07 // Set DTR, RTS
42 | #define CP210X_GET_MDMSTS 0x08 // Get modem status (DTR, RTS, CTS, DSR, RI, DCD)
43 | #define CP210X_SET_XON 0x09
44 | #define CP210X_SET_XOFF 0x0A
45 | #define CP210X_SET_EVENTMASK 0x0B
46 | #define CP210X_GET_EVENTMASK 0x0C
47 | #define CP210X_SET_CHAR 0x0D
48 | #define CP210X_GET_CHARS 0x0E
49 | #define CP210X_GET_PROPS 0x0F
50 | #define CP210X_GET_COMM_STATUS 0x10
51 | #define CP210X_RESET 0x11
52 | #define CP210X_PURGE 0x12
53 | #define CP210X_SET_FLOW 0x13
54 | #define CP210X_GET_FLOW 0x14
55 | #define CP210X_EMBED_EVENTS 0x15
56 | #define CP210X_GET_EVENTSTATE 0x16
57 | #define CP210X_SET_CHARS 0x19
58 | #define CP210X_GET_BAUDRATE 0x1D
59 | #define CP210X_SET_BAUDRATE 0x1E
60 | #define CP210X_VENDOR_SPECIFIC 0xFF // GPIO, Recipient must be Device
61 |
62 | #endif //TUSB_CP210X_H
63 |
--------------------------------------------------------------------------------
/src/class/dfu/dfu.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021 XMOS LIMITED
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 | #ifndef _TUSB_DFU_H_
28 | #define _TUSB_DFU_H_
29 |
30 | #include "common/tusb_common.h"
31 |
32 | #ifdef __cplusplus
33 | extern "C" {
34 | #endif
35 |
36 | //--------------------------------------------------------------------+
37 | // Common Definitions
38 | //--------------------------------------------------------------------+
39 |
40 | // DFU Protocol
41 | typedef enum
42 | {
43 | DFU_PROTOCOL_RT = 0x01,
44 | DFU_PROTOCOL_DFU = 0x02,
45 | } dfu_protocol_type_t;
46 |
47 | // DFU Descriptor Type
48 | typedef enum
49 | {
50 | DFU_DESC_FUNCTIONAL = 0x21,
51 | } dfu_descriptor_type_t;
52 |
53 | // DFU Requests
54 | typedef enum {
55 | DFU_REQUEST_DETACH = 0,
56 | DFU_REQUEST_DNLOAD = 1,
57 | DFU_REQUEST_UPLOAD = 2,
58 | DFU_REQUEST_GETSTATUS = 3,
59 | DFU_REQUEST_CLRSTATUS = 4,
60 | DFU_REQUEST_GETSTATE = 5,
61 | DFU_REQUEST_ABORT = 6,
62 | } dfu_requests_t;
63 |
64 | // DFU States
65 | typedef enum {
66 | APP_IDLE = 0,
67 | APP_DETACH = 1,
68 | DFU_IDLE = 2,
69 | DFU_DNLOAD_SYNC = 3,
70 | DFU_DNBUSY = 4,
71 | DFU_DNLOAD_IDLE = 5,
72 | DFU_MANIFEST_SYNC = 6,
73 | DFU_MANIFEST = 7,
74 | DFU_MANIFEST_WAIT_RESET = 8,
75 | DFU_UPLOAD_IDLE = 9,
76 | DFU_ERROR = 10,
77 | } dfu_state_t;
78 |
79 | // DFU Status
80 | typedef enum {
81 | DFU_STATUS_OK = 0x00,
82 | DFU_STATUS_ERR_TARGET = 0x01,
83 | DFU_STATUS_ERR_FILE = 0x02,
84 | DFU_STATUS_ERR_WRITE = 0x03,
85 | DFU_STATUS_ERR_ERASE = 0x04,
86 | DFU_STATUS_ERR_CHECK_ERASED = 0x05,
87 | DFU_STATUS_ERR_PROG = 0x06,
88 | DFU_STATUS_ERR_VERIFY = 0x07,
89 | DFU_STATUS_ERR_ADDRESS = 0x08,
90 | DFU_STATUS_ERR_NOTDONE = 0x09,
91 | DFU_STATUS_ERR_FIRMWARE = 0x0A,
92 | DFU_STATUS_ERR_VENDOR = 0x0B,
93 | DFU_STATUS_ERR_USBR = 0x0C,
94 | DFU_STATUS_ERR_POR = 0x0D,
95 | DFU_STATUS_ERR_UNKNOWN = 0x0E,
96 | DFU_STATUS_ERR_STALLEDPKT = 0x0F,
97 | } dfu_status_t;
98 |
99 | #define DFU_ATTR_CAN_DOWNLOAD (1u << 0)
100 | #define DFU_ATTR_CAN_UPLOAD (1u << 1)
101 | #define DFU_ATTR_MANIFESTATION_TOLERANT (1u << 2)
102 | #define DFU_ATTR_WILL_DETACH (1u << 3)
103 |
104 | // DFU Status Request Payload
105 | typedef struct TU_ATTR_PACKED
106 | {
107 | uint8_t bStatus;
108 | uint8_t bwPollTimeout[3];
109 | uint8_t bState;
110 | uint8_t iString;
111 | } dfu_status_response_t;
112 |
113 | TU_VERIFY_STATIC( sizeof(dfu_status_response_t) == 6, "size is not correct");
114 |
115 | #ifdef __cplusplus
116 | }
117 | #endif
118 |
119 | #endif /* _TUSB_DFU_H_ */
120 |
--------------------------------------------------------------------------------
/src/class/dfu/dfu_rt_device.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Sylvain Munaut
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 | #ifndef _TUSB_DFU_RT_DEVICE_H_
28 | #define _TUSB_DFU_RT_DEVICE_H_
29 |
30 | #include "dfu.h"
31 |
32 | #ifdef __cplusplus
33 | extern "C" {
34 | #endif
35 |
36 | //--------------------------------------------------------------------+
37 | // Application Callback API (weak is optional)
38 | //--------------------------------------------------------------------+
39 | // Invoked when a DFU_DETACH request is received and bitWillDetach is set
40 | void tud_dfu_runtime_reboot_to_dfu_cb(void);
41 |
42 | //--------------------------------------------------------------------+
43 | // Internal Class Driver API
44 | //--------------------------------------------------------------------+
45 | void dfu_rtd_init(void);
46 | bool dfu_rtd_deinit(void);
47 | void dfu_rtd_reset(uint8_t rhport);
48 | uint16_t dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
49 | bool dfu_rtd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
50 |
51 | #ifdef __cplusplus
52 | }
53 | #endif
54 |
55 | #endif /* _TUSB_DFU_RT_DEVICE_H_ */
56 |
--------------------------------------------------------------------------------
/src/class/net/net_device.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2020 Peter Lawrence
5 | * Copyright (c) 2019 Ha Thach (tinyusb.org)
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | *
25 | * This file is part of the TinyUSB stack.
26 | */
27 |
28 | #ifndef _TUSB_NET_DEVICE_H_
29 | #define _TUSB_NET_DEVICE_H_
30 |
31 | #include
32 | #include "class/cdc/cdc.h"
33 |
34 | #if CFG_TUD_ECM_RNDIS && CFG_TUD_NCM
35 | #error "Cannot enable both ECM_RNDIS and NCM network drivers"
36 | #endif
37 |
38 | /* declared here, NOT in usb_descriptors.c, so that the driver can intelligently ZLP as needed */
39 | #define CFG_TUD_NET_ENDPOINT_SIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
40 |
41 | /* Maximum Transmission Unit (in bytes) of the network, including Ethernet header */
42 | #ifndef CFG_TUD_NET_MTU
43 | #define CFG_TUD_NET_MTU 1514
44 | #endif
45 |
46 |
47 | // Table 4.3 Data Class Interface Protocol Codes
48 | typedef enum
49 | {
50 | NCM_DATA_PROTOCOL_NETWORK_TRANSFER_BLOCK = 0x01
51 | } ncm_data_interface_protocol_code_t;
52 |
53 |
54 | #ifdef __cplusplus
55 | extern "C" {
56 | #endif
57 |
58 | //--------------------------------------------------------------------+
59 | // Application API
60 | //--------------------------------------------------------------------+
61 |
62 | // indicate to network driver that client has finished with the packet provided to network_recv_cb()
63 | void tud_network_recv_renew(void);
64 |
65 | // poll network driver for its ability to accept another packet to transmit
66 | bool tud_network_can_xmit(uint16_t size);
67 |
68 | // if network_can_xmit() returns true, network_xmit() can be called once
69 | void tud_network_xmit(void *ref, uint16_t arg);
70 |
71 | //--------------------------------------------------------------------+
72 | // Application Callbacks (WEAK is optional)
73 | //--------------------------------------------------------------------+
74 |
75 | // client must provide this: return false if the packet buffer was not accepted
76 | bool tud_network_recv_cb(const uint8_t *src, uint16_t size);
77 |
78 | // client must provide this: copy from network stack packet pointer to dst
79 | uint16_t tud_network_xmit_cb(uint8_t *dst, void *ref, uint16_t arg);
80 |
81 | //------------- ECM/RNDIS -------------//
82 |
83 | // client must provide this: initialize any network state back to the beginning
84 | void tud_network_init_cb(void);
85 |
86 | // client must provide this: 48-bit MAC address
87 | // TODO removed later since it is not part of tinyusb stack
88 | extern uint8_t tud_network_mac_address[6];
89 |
90 | //--------------------------------------------------------------------+
91 | // INTERNAL USBD-CLASS DRIVER API
92 | //--------------------------------------------------------------------+
93 | void netd_init (void);
94 | bool netd_deinit (void);
95 | void netd_reset (uint8_t rhport);
96 | uint16_t netd_open (uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
97 | bool netd_control_xfer_cb (uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
98 | bool netd_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
99 | void netd_report (uint8_t *buf, uint16_t len);
100 |
101 | #ifdef __cplusplus
102 | }
103 | #endif
104 |
105 | #endif /* _TUSB_NET_DEVICE_H_ */
106 |
--------------------------------------------------------------------------------
/src/class/video/video_device.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach (tinyusb.org)
5 | * Copyright (c) 2021 Koji KITAYAMA
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | *
25 | * This file is part of the TinyUSB stack.
26 | */
27 |
28 | #ifndef TUSB_VIDEO_DEVICE_H_
29 | #define TUSB_VIDEO_DEVICE_H_
30 |
31 | #include "common/tusb_common.h"
32 | #include "video.h"
33 |
34 | #ifdef __cplusplus
35 | extern "C" {
36 | #endif
37 |
38 | //--------------------------------------------------------------------+
39 | // Application API (Multiple Ports)
40 | // CFG_TUD_VIDEO > 1
41 | //--------------------------------------------------------------------+
42 |
43 | /** Return true if streaming
44 | *
45 | * @param[in] ctl_idx Destination control interface index
46 | * @param[in] stm_idx Destination streaming interface index */
47 | bool tud_video_n_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx);
48 |
49 | /** Transfer a frame
50 | *
51 | * @param[in] ctl_idx Destination control interface index
52 | * @param[in] stm_idx Destination streaming interface index
53 | * @param[in] buffer Frame buffer. The caller must not use this buffer until the operation is completed.
54 | * @param[in] bufsize Byte size of the frame buffer */
55 | bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *buffer, size_t bufsize);
56 |
57 | /*------------- Optional callbacks -------------*/
58 | /** Invoked when compeletion of a frame transfer
59 | *
60 | * @param[in] ctl_idx Destination control interface index
61 | * @param[in] stm_idx Destination streaming interface index */
62 | TU_ATTR_WEAK void tud_video_frame_xfer_complete_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx);
63 |
64 | //--------------------------------------------------------------------+
65 | // Application Callback API (weak is optional)
66 | //--------------------------------------------------------------------+
67 |
68 | /** Invoked when SET_POWER_MODE request received
69 | *
70 | * @param[in] ctl_idx Destination control interface index
71 | * @param[in] stm_idx Destination streaming interface index
72 | * @return video_error_code_t */
73 | TU_ATTR_WEAK int tud_video_power_mode_cb(uint_fast8_t ctl_idx, uint8_t power_mod);
74 |
75 | /** Invoked when VS_COMMIT_CONTROL(SET_CUR) request received
76 | *
77 | * @param[in] ctl_idx Destination control interface index
78 | * @param[in] stm_idx Destination streaming interface index
79 | * @param[in] parameters Video streaming parameters
80 | * @return video_error_code_t */
81 | TU_ATTR_WEAK int tud_video_commit_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx,
82 | video_probe_and_commit_control_t const *parameters);
83 |
84 | //--------------------------------------------------------------------+
85 | // INTERNAL USBD-CLASS DRIVER API
86 | //--------------------------------------------------------------------+
87 | void videod_init (void);
88 | bool videod_deinit (void);
89 | void videod_reset (uint8_t rhport);
90 | uint16_t videod_open (uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
91 | bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
92 | bool videod_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
93 |
94 | #ifdef __cplusplus
95 | }
96 | #endif
97 |
98 | #endif
99 |
--------------------------------------------------------------------------------
/src/osal/osal.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2019 Ha Thach (tinyusb.org)
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 | #ifndef _TUSB_OSAL_H_
28 | #define _TUSB_OSAL_H_
29 |
30 | #ifdef __cplusplus
31 | extern "C" {
32 | #endif
33 |
34 | #include "common/tusb_common.h"
35 |
36 | typedef void (*osal_task_func_t)( void * );
37 |
38 | // Timeout
39 | #define OSAL_TIMEOUT_NOTIMEOUT (0) // Return immediately
40 | #define OSAL_TIMEOUT_NORMAL (10) // Default timeout
41 | #define OSAL_TIMEOUT_WAIT_FOREVER (UINT32_MAX) // Wait forever
42 | #define OSAL_TIMEOUT_CONTROL_XFER OSAL_TIMEOUT_WAIT_FOREVER
43 |
44 | // Mutex is required when using a preempted RTOS or MCU has multiple cores
45 | #if (CFG_TUSB_OS == OPT_OS_NONE) && !TUP_MCU_MULTIPLE_CORE
46 | #define OSAL_MUTEX_REQUIRED 0
47 | #define OSAL_MUTEX_DEF(_name) uint8_t :0
48 | #else
49 | #define OSAL_MUTEX_REQUIRED 1
50 | #define OSAL_MUTEX_DEF(_name) osal_mutex_def_t _name
51 | #endif
52 |
53 | // OS thin implementation
54 | #if CFG_TUSB_OS == OPT_OS_NONE
55 | #include "osal_none.h"
56 | #elif CFG_TUSB_OS == OPT_OS_FREERTOS
57 | #include "osal_freertos.h"
58 | #elif CFG_TUSB_OS == OPT_OS_MYNEWT
59 | #include "osal_mynewt.h"
60 | #elif CFG_TUSB_OS == OPT_OS_PICO
61 | #include "osal_pico.h"
62 | #elif CFG_TUSB_OS == OPT_OS_RTTHREAD
63 | #include "osal_rtthread.h"
64 | #elif CFG_TUSB_OS == OPT_OS_RTX4
65 | #include "osal_rtx4.h"
66 | #elif CFG_TUSB_OS == OPT_OS_CUSTOM
67 | #include "tusb_os_custom.h" // implemented by application
68 | #else
69 | #error OS is not supported yet
70 | #endif
71 |
72 | //--------------------------------------------------------------------+
73 | // OSAL Porting API
74 | // Should be implemented as static inline function in osal_port.h header
75 | /*
76 | osal_semaphore_t osal_semaphore_create(osal_semaphore_def_t* semdef);
77 | bool osal_semaphore_delete(osal_semaphore_t semd_hdl);
78 | bool osal_semaphore_post(osal_semaphore_t sem_hdl, bool in_isr);
79 | bool osal_semaphore_wait(osal_semaphore_t sem_hdl, uint32_t msec);
80 | void osal_semaphore_reset(osal_semaphore_t sem_hdl); // TODO removed
81 |
82 | osal_mutex_t osal_mutex_create(osal_mutex_def_t* mdef);
83 | bool osal_mutex_delete(osal_mutex_t mutex_hdl)
84 | bool osal_mutex_lock (osal_mutex_t sem_hdl, uint32_t msec);
85 | bool osal_mutex_unlock(osal_mutex_t mutex_hdl);
86 |
87 | osal_queue_t osal_queue_create(osal_queue_def_t* qdef);
88 | bool osal_queue_delete(osal_queue_t qhdl);
89 | bool osal_queue_receive(osal_queue_t qhdl, void* data, uint32_t msec);
90 | bool osal_queue_send(osal_queue_t qhdl, void const * data, bool in_isr);
91 | bool osal_queue_empty(osal_queue_t qhdl);
92 | */
93 | //--------------------------------------------------------------------+
94 |
95 | #ifdef __cplusplus
96 | }
97 | #endif
98 |
99 | #endif /* _TUSB_OSAL_H_ */
100 |
--------------------------------------------------------------------------------
/src/portable/synopsys/dwc2/dwc2_bcm.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021, Ha Thach (tinyusb.org)
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 | #ifndef _TUSB_DWC2_BCM_H_
28 | #define _TUSB_DWC2_BCM_H_
29 |
30 | #ifdef __cplusplus
31 | extern "C" {
32 | #endif
33 |
34 | #include "broadcom/defines.h"
35 | #include "broadcom/interrupts.h"
36 | #include "broadcom/caches.h"
37 |
38 | #define DWC2_EP_MAX 8
39 |
40 | static const dwc2_controller_t _dwc2_controller[] =
41 | {
42 | { .reg_base = USB_OTG_GLOBAL_BASE, .irqnum = USB_IRQn, .ep_count = DWC2_EP_MAX, .ep_fifo_size = 16384 }
43 | };
44 |
45 | #define dcache_clean(_addr, _size) data_clean(_addr, _size)
46 | #define dcache_invalidate(_addr, _size) data_invalidate(_addr, _size)
47 | #define dcache_clean_invalidate(_addr, _size) data_clean_and_invalidate(_addr, _size)
48 |
49 | TU_ATTR_ALWAYS_INLINE
50 | static inline void dwc2_dcd_int_enable(uint8_t rhport)
51 | {
52 | BP_EnableIRQ(_dwc2_controller[rhport].irqnum);
53 | }
54 |
55 | TU_ATTR_ALWAYS_INLINE
56 | static inline void dwc2_dcd_int_disable (uint8_t rhport)
57 | {
58 | BP_DisableIRQ(_dwc2_controller[rhport].irqnum);
59 | }
60 |
61 | static inline void dwc2_remote_wakeup_delay(void)
62 | {
63 | // try to delay for 1 ms
64 | // TODO implement later
65 | }
66 |
67 | // MCU specific PHY init, called BEFORE core reset
68 | static inline void dwc2_phy_init(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
69 | {
70 | (void) dwc2;
71 | (void) hs_phy_type;
72 |
73 | // nothing to do
74 | }
75 |
76 | // MCU specific PHY update, it is called AFTER init() and core reset
77 | static inline void dwc2_phy_update(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
78 | {
79 | (void) dwc2;
80 | (void) hs_phy_type;
81 |
82 | // nothing to do
83 | }
84 |
85 | #ifdef __cplusplus
86 | }
87 | #endif
88 |
89 | #endif
90 |
--------------------------------------------------------------------------------
/src/portable/synopsys/dwc2/dwc2_efm32.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021 Rafael Silva (@perigoso)
5 | * Copyright (c) 2021, Ha Thach (tinyusb.org)
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | *
25 | * This file is part of the TinyUSB stack.
26 | */
27 |
28 | #ifndef _DWC2_EFM32_H_
29 | #define _DWC2_EFM32_H_
30 |
31 | #ifdef __cplusplus
32 | extern "C" {
33 | #endif
34 |
35 | #include "em_device.h"
36 |
37 | // EFM32 has custom control register before DWC registers
38 | #define DWC2_REG_BASE (USB_BASE + offsetof(USB_TypeDef, GOTGCTL))
39 | #define DWC2_EP_MAX 7
40 |
41 | static const dwc2_controller_t _dwc2_controller[] =
42 | {
43 | { .reg_base = DWC2_REG_BASE, .irqnum = USB_IRQn, .ep_count = DWC2_EP_MAX, .ep_fifo_size = 2048 }
44 | };
45 |
46 | TU_ATTR_ALWAYS_INLINE
47 | static inline void dwc2_dcd_int_enable(uint8_t rhport)
48 | {
49 | NVIC_EnableIRQ(_dwc2_controller[rhport].irqnum);
50 | }
51 |
52 | TU_ATTR_ALWAYS_INLINE
53 | static inline void dwc2_dcd_int_disable (uint8_t rhport)
54 | {
55 | NVIC_DisableIRQ(_dwc2_controller[rhport].irqnum);
56 | }
57 |
58 | static inline void dwc2_remote_wakeup_delay(void)
59 | {
60 | // try to delay for 1 ms
61 | // uint32_t count = SystemCoreClock / 1000;
62 | // while ( count-- ) __NOP();
63 | }
64 |
65 | // MCU specific PHY init, called BEFORE core reset
66 | static inline void dwc2_phy_init(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
67 | {
68 | (void) dwc2;
69 | (void) hs_phy_type;
70 |
71 | // Enable PHY
72 | USB->ROUTE = USB_ROUTE_PHYPEN;
73 | }
74 |
75 | // MCU specific PHY update, it is called AFTER init() and core reset
76 | static inline void dwc2_phy_update(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
77 | {
78 | (void) dwc2;
79 | (void) hs_phy_type;
80 |
81 | // EFM32 Manual: turn around must be 5 (reset & default value)
82 | // dwc2->gusbcfg = (dwc2->gusbcfg & ~GUSBCFG_TRDT_Msk) | (5u << GUSBCFG_TRDT_Pos);
83 | }
84 |
85 | #ifdef __cplusplus
86 | }
87 | #endif
88 |
89 | #endif
90 |
--------------------------------------------------------------------------------
/src/portable/synopsys/dwc2/dwc2_esp32.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021, Ha Thach (tinyusb.org)
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 |
28 | #ifndef _DWC2_ESP32_H_
29 | #define _DWC2_ESP32_H_
30 |
31 | #ifdef __cplusplus
32 | extern "C" {
33 | #endif
34 |
35 | #include "freertos/task.h"
36 |
37 | #include "esp_intr_alloc.h"
38 | #include "soc/periph_defs.h"
39 | #include "soc/usb_wrap_struct.h"
40 |
41 | #if TU_CHECK_MCU(OPT_MCU_ESP32S2, OPT_MCU_ESP32S3)
42 | #define DWC2_FS_REG_BASE 0x60080000UL
43 | #define DWC2_EP_MAX 7
44 |
45 | static const dwc2_controller_t _dwc2_controller[] = {
46 | { .reg_base = DWC2_FS_REG_BASE, .irqnum = ETS_USB_INTR_SOURCE, .ep_count = 7, .ep_in_count = 5, .ep_fifo_size = 1024 }
47 | };
48 |
49 | #elif TU_CHECK_MCU(OPT_MCU_ESP32P4)
50 | #define DWC2_FS_REG_BASE 0x50040000UL
51 | #define DWC2_HS_REG_BASE 0x50000000UL
52 | #define DWC2_EP_MAX 16
53 |
54 | // On ESP32 for consistency we associate
55 | // - Port0 to OTG_FS, and Port1 to OTG_HS
56 | static const dwc2_controller_t _dwc2_controller[] = {
57 | { .reg_base = DWC2_FS_REG_BASE, .irqnum = ETS_USB_OTG11_CH0_INTR_SOURCE, .ep_count = 7, .ep_in_count = 5, .ep_fifo_size = 1024 },
58 | { .reg_base = DWC2_HS_REG_BASE, .irqnum = ETS_USB_OTG_INTR_SOURCE, .ep_count = 16, .ep_in_count = 8, .ep_fifo_size = 4096 }
59 | };
60 | #endif
61 |
62 | static intr_handle_t usb_ih[TU_ARRAY_SIZE(_dwc2_controller)];
63 |
64 | static void dcd_int_handler_wrap(void* arg) {
65 | const uint8_t rhport = (uint8_t)(uintptr_t) arg;
66 | dcd_int_handler(rhport);
67 | }
68 |
69 | TU_ATTR_ALWAYS_INLINE static inline void dwc2_dcd_int_enable(uint8_t rhport) {
70 | esp_intr_alloc(_dwc2_controller[rhport].irqnum, ESP_INTR_FLAG_LOWMED,
71 | dcd_int_handler_wrap, (void*)(uintptr_t) rhport, &usb_ih[rhport]);
72 | }
73 |
74 | TU_ATTR_ALWAYS_INLINE static inline void dwc2_dcd_int_disable(uint8_t rhport) {
75 | esp_intr_free(usb_ih[rhport]);
76 | }
77 |
78 | TU_ATTR_ALWAYS_INLINE static inline void dwc2_remote_wakeup_delay(void) {
79 | vTaskDelay(pdMS_TO_TICKS(1));
80 | }
81 |
82 | // MCU specific PHY init, called BEFORE core reset
83 | TU_ATTR_ALWAYS_INLINE static inline void dwc2_phy_init(dwc2_regs_t* dwc2, uint8_t hs_phy_type) {
84 | (void)dwc2;
85 | (void)hs_phy_type;
86 | // nothing to do
87 | }
88 |
89 | // MCU specific PHY update, it is called AFTER init() and core reset
90 | TU_ATTR_ALWAYS_INLINE static inline void dwc2_phy_update(dwc2_regs_t* dwc2, uint8_t hs_phy_type) {
91 | (void)dwc2;
92 | (void)hs_phy_type;
93 | // nothing to do
94 | }
95 |
96 | #ifdef __cplusplus
97 | }
98 | #endif
99 |
100 | #endif
101 |
--------------------------------------------------------------------------------
/src/portable/synopsys/dwc2/dwc2_gd32.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021, Ha Thach (tinyusb.org)
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | *
24 | * This file is part of the TinyUSB stack.
25 | */
26 |
27 |
28 | #ifndef DWC2_GD32_H_
29 | #define DWC2_GD32_H_
30 |
31 | #ifdef __cplusplus
32 | extern "C" {
33 | #endif
34 |
35 | #define DWC2_REG_BASE 0x50000000UL
36 | #define DWC2_EP_MAX 4
37 |
38 | static const dwc2_controller_t _dwc2_controller[] =
39 | {
40 | { .reg_base = DWC2_REG_BASE, .irqnum = 86, .ep_count = DWC2_EP_MAX, .ep_fifo_size = 1280 }
41 | };
42 |
43 | extern uint32_t SystemCoreClock;
44 |
45 | // The GD32VF103 is a RISC-V MCU, which implements the ECLIC Core-Local
46 | // Interrupt Controller by Nuclei. It is nearly API compatible to the
47 | // NVIC used by ARM MCUs.
48 | #define ECLIC_INTERRUPT_ENABLE_BASE 0xD2001001UL
49 |
50 | TU_ATTR_ALWAYS_INLINE
51 | static inline void __eclic_enable_interrupt (uint32_t irq) {
52 | *(volatile uint8_t*)(ECLIC_INTERRUPT_ENABLE_BASE + (irq * 4)) = 1;
53 | }
54 |
55 | TU_ATTR_ALWAYS_INLINE
56 | static inline void __eclic_disable_interrupt (uint32_t irq){
57 | *(volatile uint8_t*)(ECLIC_INTERRUPT_ENABLE_BASE + (irq * 4)) = 0;
58 | }
59 |
60 | TU_ATTR_ALWAYS_INLINE
61 | static inline void dwc2_dcd_int_enable(uint8_t rhport)
62 | {
63 | __eclic_enable_interrupt(_dwc2_controller[rhport].irqnum);
64 | }
65 |
66 | TU_ATTR_ALWAYS_INLINE
67 | static inline void dwc2_dcd_int_disable (uint8_t rhport)
68 | {
69 | __eclic_disable_interrupt(_dwc2_controller[rhport].irqnum);
70 | }
71 |
72 | static inline void dwc2_remote_wakeup_delay(void)
73 | {
74 | // try to delay for 1 ms
75 | uint32_t count = SystemCoreClock / 1000;
76 | while ( count-- ) __asm volatile ("nop");
77 | }
78 |
79 | // MCU specific PHY init, called BEFORE core reset
80 | static inline void dwc2_phy_init(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
81 | {
82 | (void) dwc2;
83 | (void) hs_phy_type;
84 |
85 | // nothing to do
86 | }
87 |
88 | // MCU specific PHY update, it is called AFTER init() and core reset
89 | static inline void dwc2_phy_update(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
90 | {
91 | (void) dwc2;
92 | (void) hs_phy_type;
93 |
94 | // nothing to do
95 | }
96 |
97 | #ifdef __cplusplus
98 | }
99 | #endif
100 |
101 | #endif /* DWC2_GD32_H_ */
102 |
--------------------------------------------------------------------------------
/src/portable/synopsys/dwc2/dwc2_xmc.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2021 Rafael Silva (@perigoso)
5 | * Copyright (c) 2021, Ha Thach (tinyusb.org)
6 | *
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy
8 | * of this software and associated documentation files (the "Software"), to deal
9 | * in the Software without restriction, including without limitation the rights
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | * copies of the Software, and to permit persons to whom the Software is
12 | * furnished to do so, subject to the following conditions:
13 | *
14 | * The above copyright notice and this permission notice shall be included in
15 | * all copies or substantial portions of the Software.
16 | *
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | * THE SOFTWARE.
24 | *
25 | * This file is part of the TinyUSB stack.
26 | */
27 |
28 | #ifndef _DWC2_XMC_H_
29 | #define _DWC2_XMC_H_
30 |
31 | #ifdef __cplusplus
32 | extern "C" {
33 | #endif
34 |
35 | #include "xmc_device.h"
36 |
37 | #define DWC2_EP_MAX 7
38 |
39 | static const dwc2_controller_t _dwc2_controller[] =
40 | {
41 | // Note: XMC has some custom control registers before DWC registers
42 | { .reg_base = USB0_BASE, .irqnum = USB0_0_IRQn, .ep_count = DWC2_EP_MAX, .ep_fifo_size = 2048 }
43 | };
44 |
45 | TU_ATTR_ALWAYS_INLINE
46 | static inline void dwc2_dcd_int_enable(uint8_t rhport)
47 | {
48 | NVIC_EnableIRQ(_dwc2_controller[rhport].irqnum);
49 | }
50 |
51 | TU_ATTR_ALWAYS_INLINE
52 | static inline void dwc2_dcd_int_disable (uint8_t rhport)
53 | {
54 | NVIC_DisableIRQ(_dwc2_controller[rhport].irqnum);
55 | }
56 |
57 | static inline void dwc2_remote_wakeup_delay(void)
58 | {
59 | // try to delay for 1 ms
60 | // uint32_t count = SystemCoreClock / 1000;
61 | // while ( count-- ) __NOP();
62 | }
63 |
64 | // MCU specific PHY init, called BEFORE core reset
65 | static inline void dwc2_phy_init(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
66 | {
67 | (void) dwc2;
68 | (void) hs_phy_type;
69 |
70 | // Enable PHY
71 | //USB->ROUTE = USB_ROUTE_PHYPEN;
72 | }
73 |
74 | // MCU specific PHY update, it is called AFTER init() and core reset
75 | static inline void dwc2_phy_update(dwc2_regs_t * dwc2, uint8_t hs_phy_type)
76 | {
77 | (void) dwc2;
78 | (void) hs_phy_type;
79 |
80 | // XMC Manual: turn around must be 5 (reset & default value)
81 | // dwc2->gusbcfg = (dwc2->gusbcfg & ~GUSBCFG_TRDT_Msk) | (5u << GUSBCFG_TRDT_Pos);
82 | }
83 |
84 | #ifdef __cplusplus
85 | }
86 | #endif
87 |
88 | #endif
89 |
--------------------------------------------------------------------------------
/src/tusb_config.h:
--------------------------------------------------------------------------------
1 | /*
2 | * The MIT License (MIT)
3 | *
4 | * Copyright (c) 2018, hathach for Adafruit
5 | *
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy
7 | * of this software and associated documentation files (the "Software"), to deal
8 | * in the Software without restriction, including without limitation the rights
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | * copies of the Software, and to permit persons to whom the Software is
11 | * furnished to do so, subject to the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be included in
14 | * all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | * THE SOFTWARE.
23 | */
24 |
25 | #ifndef TUSB_CONFIG_ARDUINO_H_
26 | #define TUSB_CONFIG_ARDUINO_H_
27 |
28 | #ifdef __cplusplus
29 | extern "C" {
30 | #endif
31 |
32 | #if defined(ARDUINO_ARCH_SAMD)
33 | #include "arduino/ports/samd/tusb_config_samd.h"
34 |
35 | #elif defined(ARDUINO_NRF52_ADAFRUIT)
36 | #include "arduino/ports/nrf/tusb_config_nrf.h"
37 |
38 | #elif defined(ARDUINO_ARCH_RP2040)
39 | #include "arduino/ports/rp2040/tusb_config_rp2040.h"
40 |
41 | #elif defined(ARDUINO_ARCH_ESP32)
42 | // Note: when compiling core Arduino IDEs will include tusb_config.h in the BSP
43 | // sdk/include/arduino_tinyusb/include. While compiling .c file in this library this
44 | // file will be used instead. For consistency: include the one in BSP here as well
45 | #include "sdkconfig.h"
46 | #if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
47 | #include "../../arduino_tinyusb/include/tusb_config.h"
48 | #else
49 | #include "arduino/ports/esp32/tusb_config_esp32.h"
50 | #endif
51 |
52 | // Note: For platformio prioritize this file over the one in BSP in all cases
53 |
54 | #elif defined(ARDUINO_ARCH_CH32) || defined(CH32V20x) || defined(CH32V30x)
55 | #include "arduino/ports/ch32/tusb_config_ch32.h"
56 | #else
57 | #error TinyUSB Arduino Library does not support your core yet
58 | #endif
59 |
60 | // Debug TinyUSB with Serial1
61 | #if CFG_TUSB_DEBUG
62 | #define CFG_TUSB_DEBUG_PRINTF log_printf
63 | #endif
64 |
65 | #ifdef __cplusplus
66 | }
67 | #endif
68 |
69 | #endif
70 |
--------------------------------------------------------------------------------
/tools/update-usbh_helper.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | import click
3 | import sys
4 | import shutil
5 |
6 | @click.command()
7 | @click.argument('dir', type=click.Path(), required=True)
8 | def main(dir):
9 | """
10 | This script takes a mandatory 'dir' argument, which is a path to pivot example to update for all DualRole's examples
11 | """
12 | sample_dir = Path(dir)
13 | if not sample_dir.is_dir():
14 | # add examples/DualRoles to the path
15 | sample_dir = Path('examples/DualRole') / sample_dir
16 | if not sample_dir.is_dir():
17 | click.echo(f"The specified dir '{dir}' does not exist or is not a valid dir.")
18 | sys.exit(1)
19 |
20 | sample_file = sample_dir / 'usbh_helper.h'
21 | f_list = sorted(Path('examples/DualRole').glob('**/usbh_helper.h'))
22 | for f in f_list:
23 | if f != sample_file:
24 | click.echo(f"Updating {f}")
25 | shutil.copy(sample_file, f)
26 |
27 |
28 | if __name__ == '__main__':
29 | main()
--------------------------------------------------------------------------------