SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Update USB_FLASH_DRIVE_SUPPORT (#15021)

Browse source
This commit is contained in:
Marcio Teixeira 2019-08-24 00:47:19 -06:00 committed by Scott Lahteine
parent 20fc66f875
commit da601d5114
149 changed files with 12939 additions and 693 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
Marlin/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

288
Marlin/src/sd/usb_flashdrive/Sd2Card_FlashDrive.cpp
View file

@ -22,12 +22,75 @@
#include "../../inc/MarlinConfigPre.h"
/**
* Adjust USB_DEBUG to select debugging verbosity.
* 0 - no debug messages
* 1 - basic insertion/removal messages
* 2 - show USB state transitions
* 3 - perform block range checking
* 4 - print each block access
*/
#define USB_DEBUG 1
#define USB_STARTUP_DELAY 0
// uncomment to get 'printf' console debugging. NOT FOR UNO!
//#define HOST_DEBUG(...) {char s[255]; sprintf(s,__VA_ARGS__); SERIAL_ECHOLNPAIR("UHS:",s);}
//#define BS_HOST_DEBUG(...) {char s[255]; sprintf(s,__VA_ARGS__); SERIAL_ECHOLNPAIR("UHS:",s);}
//#define MAX_HOST_DEBUG(...) {char s[255]; sprintf(s,__VA_ARGS__); SERIAL_ECHOLNPAIR("UHS:",s);}
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#include "../../Marlin.h"
#include "../../core/serial.h"
#include "../../module/temperature.h"
#include "lib/Usb.h"
#include "lib/masstorage.h"
static_assert(USB_CS_PIN != -1, "USB_CS_PIN must be defined");
static_assert(USB_INTR_PIN != -1, "USB_INTR_PIN must be defined");
#if ENABLED(USE_UHS3_USB)
#define NO_AUTO_SPEED
#define UHS_MAX3421E_SPD 8000000 >> SPI_SPEED
#define UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE 1
#define UHS_HOST_MAX_INTERFACE_DRIVERS 2
#define MASS_MAX_SUPPORTED_LUN 1
#define USB_HOST_SERIAL MYSERIAL0
// Workaround for certain issues with UHS3
#define SKIP_PAGE3F // Required for IOGEAR media adapter
#define USB_NO_TEST_UNIT_READY // Required for removable media adapter
#define USB_HOST_MANUAL_POLL // Optimization to shut off IRQ automatically
// Workarounds for keeping Marlin's watchdog timer from barking...
void marlin_yield() {
thermalManager.manage_heater();
}
#define SYSTEM_OR_SPECIAL_YIELD(...) marlin_yield();
#define delay(x) safe_delay(x)
#define LOAD_USB_HOST_SYSTEM
#define LOAD_USB_HOST_SHIELD
#define LOAD_UHS_BULK_STORAGE
#define MARLIN_UHS_WRITE_SS(v) WRITE(USB_CS_PIN, v)
#define MARLIN_UHS_READ_IRQ() READ(USB_INTR_PIN)
#include "lib-uhs3/UHS_host/UHS_host.h"
MAX3421E_HOST usb(USB_CS_PIN, USB_INTR_PIN);
UHS_Bulk_Storage bulk(&usb);
#define UHS_START (usb.Init() == 0)
#define UHS_STATE(state) UHS_USB_HOST_STATE_##state
#else
#include "lib-uhs2/Usb.h"
#include "lib-uhs2/masstorage.h"
USB usb;
BulkOnly bulk(&usb);
#define UHS_START usb.start()
#define UHS_STATE(state) USB_STATE_##state
#endif
#include "Sd2Card_FlashDrive.h"
@ -35,10 +98,41 @@
#include "../../lcd/ultralcd.h"
#endif
USB usb;
BulkOnly bulk(&usb);
static enum {
UNINITIALIZED,
DO_STARTUP,
WAIT_FOR_DEVICE,
WAIT_FOR_LUN,
MEDIA_READY,
MEDIA_ERROR
} state;
Sd2Card::state_t Sd2Card::state;
#if USB_DEBUG >= 3
uint32_t lun0_capacity;
#endif
bool Sd2Card::usbStartup() {
if (state <= DO_STARTUP) {
SERIAL_ECHOPGM("Starting USB host...");
if (!UHS_START) {
SERIAL_ECHOLNPGM(" failed.");
#if EITHER(ULTRA_LCD, EXTENSIBLE_UI)
LCD_MESSAGEPGM("USB start failed");
#endif
return false;
}
// SPI quick test - check revision register
switch (usb.regRd(rREVISION)) {
case 0x01: SERIAL_ECHOLNPGM("rev.01 started"); break;
case 0x12: SERIAL_ECHOLNPGM("rev.02 started"); break;
case 0x13: SERIAL_ECHOLNPGM("rev.03 started"); break;
default: SERIAL_ECHOLNPGM("started. rev unknown."); break;
}
state = WAIT_FOR_DEVICE;
}
return true;
}
// The USB library needs to be called periodically to detect USB thumbdrive
// insertion and removals. Call this idle() function periodically to allow
@ -46,75 +140,145 @@ Sd2Card::state_t Sd2Card::state;
// of initializing the USB library for the first time.
void Sd2Card::idle() {
static uint32_t next_retry;
usb.Task();
switch (state) {
case USB_HOST_DELAY_INIT:
next_retry = millis() + 2000;
state = USB_HOST_WAITING;
break;
case USB_HOST_WAITING:
if (ELAPSED(millis(), next_retry)) {
next_retry = millis() + 2000;
state = USB_HOST_UNINITIALIZED;
}
break;
case USB_HOST_UNINITIALIZED:
SERIAL_ECHOPGM("Starting USB host...");
if (!usb.start()) {
SERIAL_ECHOPGM(" Failed. Retrying in 2s.");
#if HAS_DISPLAY
LCD_MESSAGEPGM("USB start failed");
#endif
state = USB_HOST_DELAY_INIT;
}
else
state = USB_HOST_INITIALIZED;
SERIAL_EOL();
break;
case USB_HOST_INITIALIZED:
const uint8_t lastUsbTaskState = usb.getUsbTaskState();
usb.Task();
const uint8_t newUsbTaskState = usb.getUsbTaskState();
const uint8_t task_state = usb.getUsbTaskState();
if (lastUsbTaskState == USB_STATE_RUNNING && newUsbTaskState != USB_STATE_RUNNING) {
// the user pulled the flash drive. Make sure the bulk storage driver releases the address
#ifdef USB_DEBUG
SERIAL_ECHOLNPGM("USB drive removed");
#endif
//bulk.Release();
#if USB_DEBUG >= 2
if (state > DO_STARTUP) {
static uint8_t laststate = 232;
if (task_state != laststate) {
laststate = task_state;
#define UHS_USB_DEBUG(x) case UHS_STATE(x): SERIAL_ECHOLNPGM(#x); break
switch (task_state) {
UHS_USB_DEBUG(IDLE);
UHS_USB_DEBUG(RESET_DEVICE);
UHS_USB_DEBUG(RESET_NOT_COMPLETE);
UHS_USB_DEBUG(DEBOUNCE);
UHS_USB_DEBUG(DEBOUNCE_NOT_COMPLETE);
UHS_USB_DEBUG(WAIT_SOF);
UHS_USB_DEBUG(ERROR);
UHS_USB_DEBUG(CONFIGURING);
UHS_USB_DEBUG(CONFIGURING_DONE);
UHS_USB_DEBUG(RUNNING);
default:
SERIAL_ECHOLNPAIR("UHS_USB_HOST_STATE: ", task_state);
break;
}
}
if (lastUsbTaskState != USB_STATE_RUNNING && newUsbTaskState == USB_STATE_RUNNING) {
#ifdef USB_DEBUG
SERIAL_ECHOLNPGM("USB drive inserted");
}
#endif
static millis_t next_state_ms = millis();
#define GOTO_STATE_AFTER_DELAY(STATE, DELAY) do{ state = STATE; next_state_ms = millis() + DELAY; }while(0)
if (ELAPSED(millis(), next_state_ms)) {
GOTO_STATE_AFTER_DELAY(state, 250); // Default delay
switch (state) {
case UNINITIALIZED:
#ifndef MANUAL_USB_STARTUP
GOTO_STATE_AFTER_DELAY( DO_STARTUP, USB_STARTUP_DELAY );
#endif
}
break;
break;
case DO_STARTUP: usbStartup(); break;
case WAIT_FOR_DEVICE:
if (task_state == UHS_STATE(RUNNING)) {
#if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("USB device inserted");
#endif
GOTO_STATE_AFTER_DELAY( WAIT_FOR_LUN, 250 );
}
break;
case WAIT_FOR_LUN:
/* USB device is inserted, but if it is an SD card,
* adapter it may not have an SD card in it yet. */
if (bulk.LUNIsGood(0)) {
#if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("LUN is good");
#endif
GOTO_STATE_AFTER_DELAY( MEDIA_READY, 100 );
}
else {
#ifdef USB_HOST_MANUAL_POLL
// Make sure we catch disconnect events
usb.busprobe();
usb.VBUS_changed();
#endif
#if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("Waiting for media");
#endif
#if EITHER(ULTRA_LCD, EXTENSIBLE_UI)
LCD_MESSAGEPGM("Waiting for media");
#endif
GOTO_STATE_AFTER_DELAY(state, 2000);
}
break;
case MEDIA_READY: break;
case MEDIA_ERROR: break;
}
if (state > WAIT_FOR_DEVICE && task_state != UHS_STATE(RUNNING)) {
// Handle device removal events
#if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("USB device removed");
#endif
#if EITHER(ULTRA_LCD, EXTENSIBLE_UI)
if (state != MEDIA_READY)
LCD_MESSAGEPGM("USB device removed");
#endif
GOTO_STATE_AFTER_DELAY( WAIT_FOR_DEVICE, 0 );
}
else if (state > WAIT_FOR_LUN && !bulk.LUNIsGood(0)) {
// Handle media removal events
#if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("Media removed");
#endif
#if EITHER(ULTRA_LCD, EXTENSIBLE_UI)
LCD_MESSAGEPGM("Media removed");
#endif
GOTO_STATE_AFTER_DELAY( WAIT_FOR_DEVICE, 0 );
}
else if (task_state == UHS_STATE(ERROR)) {
#if EITHER(ULTRA_LCD, EXTENSIBLE_UI)
LCD_MESSAGEPGM("Media read error");
#endif
GOTO_STATE_AFTER_DELAY( MEDIA_ERROR, 0 );
}
}
}
// Marlin calls this function to check whether an USB drive is inserted.
// This is equivalent to polling the SD_DETECT when using SD cards.
bool Sd2Card::isInserted() {
return usb.getUsbTaskState() == USB_STATE_RUNNING;
return state == MEDIA_READY;
}
bool Sd2Card::ready() {
return state > DO_STARTUP;
}
// Marlin calls this to initialize an SD card once it is inserted.
bool Sd2Card::init(const uint8_t sckRateID/*=0*/, const pin_t chipSelectPin/*=SD_CHIP_SELECT_PIN*/) {
if (!ready()) return false;
if (!bulk.LUNIsGood(0)) {
SERIAL_ECHOLNPGM("LUN zero is not good");
return false;
}
bool Sd2Card::init(const uint8_t, const pin_t) {
if (!isInserted()) return false;
#if USB_DEBUG >= 1
const uint32_t sectorSize = bulk.GetSectorSize(0);
if (sectorSize != 512) {
SERIAL_ECHOLNPAIR("Expecting sector size of 512. Got: ", sectorSize);
return false;
}
#endif
#ifdef USB_DEBUG
#if USB_DEBUG >= 3
lun0_capacity = bulk.GetCapacity(0);
SERIAL_ECHOLNPAIR("LUN Capacity (in blocks): ", lun0_capacity);
#endif
@ -123,8 +287,8 @@ bool Sd2Card::init(const uint8_t sckRateID/*=0*/, const pin_t chipSelectPin/*=SD
// Returns the capacity of the card in blocks.
uint32_t Sd2Card::cardSize() {
if (!ready()) return 0;
#ifndef USB_DEBUG
if (!isInserted()) return false;
#if USB_DEBUG < 3
const uint32_t
#endif
lun0_capacity = bulk.GetCapacity(0);
@ -132,13 +296,13 @@ uint32_t Sd2Card::cardSize() {
}
bool Sd2Card::readBlock(uint32_t block, uint8_t* dst) {
if (!ready()) return false;
#ifdef USB_DEBUG
if (!isInserted()) return false;
#if USB_DEBUG >= 3
if (block >= lun0_capacity) {
SERIAL_ECHOLNPAIR("Attempt to read past end of LUN: ", block);
return false;
}
#if USB_DEBUG > 1
#if USB_DEBUG >= 4
SERIAL_ECHOLNPAIR("Read block ", block);
#endif
#endif
@ -146,13 +310,13 @@ bool Sd2Card::readBlock(uint32_t block, uint8_t* dst) {
}
bool Sd2Card::writeBlock(uint32_t block, const uint8_t* src) {
if (!ready()) return false;
#ifdef USB_DEBUG
if (!isInserted()) return false;
#if USB_DEBUG >= 3
if (block >= lun0_capacity) {
SERIAL_ECHOLNPAIR("Attempt to write past end of LUN: ", block);
return false;
}
#if USB_DEBUG > 1
#if USB_DEBUG >= 4
SERIAL_ECHOLNPAIR("Write block ", block);
#endif
#endif

24
Marlin/src/sd/usb_flashdrive/Sd2Card_FlashDrive.h
View file

@ -26,12 +26,6 @@
* \brief Sd2Card class for V2 SD/SDHC cards
*/
/* Uncomment USB_DEBUG to enable debugging.
* 1 - basic debugging and bounds checking
* 2 - print each block access
*/
//#define USB_DEBUG 1
#include "../SdFatConfig.h"
#include "../SdInfo.h"
@ -52,24 +46,13 @@
class Sd2Card {
private:
typedef enum : uint8_t {
USB_HOST_UNINITIALIZED,
USB_HOST_INITIALIZED,
USB_HOST_DELAY_INIT,
USB_HOST_WAITING
} state_t;
static state_t state;
uint32_t pos;
#ifdef USB_DEBUG
uint32_t lun0_capacity;
#endif
static inline bool ready() { return state == USB_HOST_INITIALIZED; }
static void usbStateDebug();
public:
static bool usbStartup();
bool init(const uint8_t sckRateID=0, const pin_t chipSelectPin=SD_CHIP_SELECT_PIN);
static void idle();
@ -87,4 +70,5 @@ class Sd2Card {
uint32_t cardSize();
static bool isInserted();
static bool ready();
};

20
Marlin/src/sd/usb_flashdrive/SOURCES.txt → Marlin/src/sd/usb_flashdrive/lib-uhs2/README.txt
View file

@ -1,15 +1,4 @@
==== SUMMARY ====
Source Path: Repository: License:
------------ ----------- --------
usb_flashdrive/lib github.com/felis/USB_Host_Shield_2.0 GPLv2 or later
usb_flashdrive/lib/masstorage.cpp [1] github.com/greiman/UsbFat MIT
usb_flashdrive/lib/settings.h [1] github.com/greiman/UsbFat MIT
[1] Changes related to SKIP_WRITE_PROTECT and DELAY only
==== USB HOST SHIELD 2.0 LIBRARY ====
The lib/ folder contains a subset of the files from the USB Host Shield 2.0
@ -26,6 +15,15 @@ files needed for Marlin as "GPLv2 or later", as documented in this thread.
Small modifications have been made to the source. Please search for
USB_FLASH_DRIVE_SUPPORT or look at the patch file to see what was changed.
==== LICENSE SUMMARY ====
Source Path: Repository: License:
------------ ----------- --------
lib-uhs3/ github.com/felis/USB_Host_Shield_2.0 GPLv2 or later
lib-uhs3/lib/masstorage.cpp github.com/greiman/UsbFat [1] MIT
lib-uhs3/lib/settings.h github.com/greiman/UsbFat [1] MIT
[1] Changes related to SKIP_WRITE_PROTECT and DELAY only
==== PERFORMANCE ENHANCEMENTS FOR USB DRIVES ====

2
Marlin/src/sd/usb_flashdrive/lib/Usb.cpp → Marlin/src/sd/usb_flashdrive/lib-uhs2/Usb.cpp
View file

@ -26,7 +26,7 @@
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) && DISABLED(USE_UHS3_USB)
#include "Usb.h"

3
Marlin/src/sd/usb_flashdrive/lib/Usb.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/Usb.h
View file

@ -45,8 +45,7 @@
#include "address.h"
//#include "avrpins.h"
#include "usb_ch9.h"
//#include "usbhost.h"
#include "../usb_host.h"
#include "usbhost.h"
#include "UsbCore.h"
#include "parsetools.h"
#include "confdescparser.h"

0
Marlin/src/sd/usb_flashdrive/lib/UsbCore.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/UsbCore.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/address.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/address.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/confdescparser.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/confdescparser.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/hexdump.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/hexdump.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/macros.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/macros.h
View file

4
Marlin/src/sd/usb_flashdrive/lib/masstorage.cpp → Marlin/src/sd/usb_flashdrive/lib-uhs2/masstorage.cpp
View file

@ -25,7 +25,7 @@
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) && DISABLED(USE_UHS3_USB)
#include "masstorage.h"
@ -762,7 +762,7 @@ uint8_t BulkOnly::Page3F(uint8_t lun) {
buf[i] = 0x00;
}
WriteOk[lun] = true;
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) && defined(SKIP_WRITE_PROTECT)
#ifdef SKIP_WRITE_PROTECT
return 0;
#endif
uint8_t rc = ModeSense6(lun, 0, 0x3f, 0, 192, buf);

0
Marlin/src/sd/usb_flashdrive/lib/masstorage.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/masstorage.h
View file

9
Marlin/src/sd/usb_flashdrive/lib/max3421e.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/max3421e.h
View file

@ -191,6 +191,15 @@
#define bmSNDTOG1 0x80
#define rHXFR 0xf0 //30<<3
#undef tokSETUP
#undef tokIN
#undef tokOUT
#undef tokINHS
#undef tokOUTHS
#undef tokISOIN
#undef tokISOOUT
/* Host transfer token values for writing the HXFR register (R30) */
/* OR this bit field with the endpoint number in bits 3:0 */
#define tokSETUP 0x10 // HS=0, ISO=0, OUTNIN=0, SETUP=1

2
Marlin/src/sd/usb_flashdrive/lib/message.cpp → Marlin/src/sd/usb_flashdrive/lib-uhs2/message.cpp
View file

@ -25,7 +25,7 @@
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) && DISABLED(USE_UHS3_USB)
#include "Usb.h"

0
Marlin/src/sd/usb_flashdrive/lib/message.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/message.h
View file

2
Marlin/src/sd/usb_flashdrive/lib/parsetools.cpp → Marlin/src/sd/usb_flashdrive/lib-uhs2/parsetools.cpp
View file

@ -25,7 +25,7 @@
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) && DISABLED(USE_UHS3_USB)
#include "Usb.h"

0
Marlin/src/sd/usb_flashdrive/lib/parsetools.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/parsetools.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/printhex.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/printhex.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/settings.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/settings.h
View file

0
Marlin/src/sd/usb_flashdrive/lib/usb_ch9.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/usb_ch9.h
View file

8
Marlin/src/sd/usb_flashdrive/usb_host.cpp → Marlin/src/sd/usb_flashdrive/lib-uhs2/usbhost.cpp
View file

@ -23,12 +23,12 @@
* lib/usbhost.c". This has been rewritten to use SPI routines from the
* Marlin HAL */
#include "../../inc/MarlinConfigPre.h"
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) && DISABLED(USE_UHS3_USB)
#include "lib/Usb.h"
#include "usb_host.h"
#include "Usb.h"
#include "usbhost.h"
uint8_t MAX3421e::vbusState = 0;

0
Marlin/src/sd/usb_flashdrive/usb_host.h → Marlin/src/sd/usb_flashdrive/lib-uhs2/usbhost.h
View file

31
Marlin/src/sd/usb_flashdrive/lib-uhs3/README.txt Normal file
View file

@ -0,0 +1,31 @@
==== USB HOST SHIELD 3.0 LIBRARY ====
The lib-uhs3/ folder contains a subset of the files from the USB Host Shield
3.0 library:
https://github.com/felis/UHS30
==== LICENSE SUMMARY ====
Source Path: Repository: License:
------------ ----------- --------
usb_flashdrive/lib github.com/felis/UHS30 GPLv2 or later
==== MARLIN INTEGRATION WORK ====
All additional work done to integrate USB into Marlin was performed by
AlephObjects, Inc. and is licensed under the GPLv3.
This version of UHS3 has been modified for better compatibility with Marlin.
The upstream version of UHS 3.0 runs a frame timer interrupt every 1 ms to
handle device polling. This timer interrupt interferes with Marlin's stepper
IRQ, so the flag USB_HOST_MANUAL_POLL has been added to move the polling to
the idle task. Additional logic was added to disable and enable the frame
IRQ.
SKIP_PAGE3F and USB_NO_TEST_UNIT_READY were added to work around bugs with
certain devices.
-- marcio@alephobjects.com

249
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_BULK_STORAGE/UHS_BULK_STORAGE.h Normal file
View file

@ -0,0 +1,249 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(__UHS_BULK_STORAGE_H__)
#define __UHS_BULK_STORAGE_H__
////////////////////////////////////////////////////////////////////////////////
// Define any of these options at the top of your sketch to override
// the defaults contained herewith. Do NOT do modifications here.
// Macro | Settings and notes | Default
// -----------------------------------------+-----------------------+-----------
// | 1 to 8 |
// | Each LUN needs |
// MASS_MAX_SUPPORTED_LUN | ~13 bytes to be able | 8
// | to track the state of |
// | each unit. |
// -----------------------------------------+-----------------------+-----------
// | Just define to use. |
// DEBUG_PRINTF_EXTRA_HUGE_UHS_BULK_STORAGE | works only if extra |
// | huge debug is on too. |
// -----------------------------------------^-----------------------^-----------
#ifndef MASS_MAX_SUPPORTED_LUN
#define MASS_MAX_SUPPORTED_LUN 8
#endif
#include "UHS_SCSI.h"
#define UHS_BULK_bmREQ_OUT USB_SETUP_HOST_TO_DEVICE|USB_SETUP_TYPE_CLASS|USB_SETUP_RECIPIENT_INTERFACE
#define UHS_BULK_bmREQ_IN USB_SETUP_DEVICE_TO_HOST|USB_SETUP_TYPE_CLASS|USB_SETUP_RECIPIENT_INTERFACE
// Request Codes
#define UHS_BULK_REQ_ADSC 0x00U
#define UHS_BULK_REQ_GET 0xFCU
#define UHS_BULK_REQ_PUT 0xFDU
#define UHS_BULK_REQ_GET_MAX_LUN 0xFEU
#define UHS_BULK_REQ_BOMSR 0xFFU // Mass Storage Reset
#define UHS_BULK_CBW_SIGNATURE 0x43425355LU
#define UHS_BULK_CSW_SIGNATURE 0x53425355LU
#define UHS_BULK_CMD_DIR_OUT 0x00U
#define UHS_BULK_CMD_DIR_IN 0x80U
/* Bulk error codes */
#define UHS_BULK_ERR_SUCCESS UHS_HOST_ERROR_NONE
#define UHS_BULK_ERR_PHASE_ERROR 0x22U
#define UHS_BULK_ERR_UNIT_NOT_READY 0x23U
#define UHS_BULK_ERR_UNIT_BUSY 0x24U
#define UHS_BULK_ERR_STALL 0x25U
#define UHS_BULK_ERR_CMD_NOT_SUPPORTED 0x26U
#define UHS_BULK_ERR_INVALID_CSW 0x27U
#define UHS_BULK_ERR_NO_MEDIA 0x28U
#define UHS_BULK_ERR_BAD_LBA 0x29U
#define UHS_BULK_ERR_MEDIA_CHANGED 0x2AU
#define UHS_BULK_ERR_DEVICE_DISCONNECTED UHS_HOST_ERROR_UNPLUGGED
#define UHS_BULK_ERR_UNABLE_TO_RECOVER 0x32U // Reset recovery error
#define UHS_BULK_ERR_INVALID_LUN 0x33U
#define UHS_BULK_ERR_WRITE_STALL 0x34U
#define UHS_BULK_ERR_READ_NAKS 0x35U
#define UHS_BULK_ERR_WRITE_NAKS 0x36U
#define UHS_BULK_ERR_WRITE_PROTECTED 0x37U
#define UHS_BULK_ERR_NOT_IMPLEMENTED 0xFDU
#define UHS_BULK_ERR_GENERAL_SCSI_ERROR 0xF0U
#define UHS_BULK_ERR_GENERAL_USB_ERROR 0xFFU
#define UHS_BULK_ERR_USER 0xA0U // For subclasses to define their own error codes
#define MASS_MAX_ENDPOINTS 3
struct UHS_BULK_CommandBlockWrapperBase {
volatile uint32_t dCBWSignature;
volatile uint32_t dCBWTag;
volatile uint32_t dCBWDataTransferLength;
volatile uint8_t bmCBWFlags;
public:
UHS_BULK_CommandBlockWrapperBase(void) {
}
UHS_BULK_CommandBlockWrapperBase(uint32_t tag, uint32_t xflen, uint8_t flgs) :
dCBWSignature(UHS_BULK_CBW_SIGNATURE), dCBWTag(tag), dCBWDataTransferLength(xflen), bmCBWFlags(flgs) {
}
} __attribute__((packed));
struct UHS_BULK_CommandBlockWrapper : public UHS_BULK_CommandBlockWrapperBase {
struct {
uint8_t bmCBWLUN : 4;
uint8_t bmReserved1 : 4;
};
struct {
uint8_t bmCBWCBLength : 4;
uint8_t bmReserved2 : 4;
};
uint8_t CBWCB[16];
public:
// All zeroed.
UHS_BULK_CommandBlockWrapper() :
UHS_BULK_CommandBlockWrapperBase(0, 0, 0), bmReserved1(0), bmReserved2(0) {
for(int i = 0; i < 16; i++) CBWCB[i] = 0;
}
// Generic Wrap, CDB zeroed.
UHS_BULK_CommandBlockWrapper(uint32_t tag, uint32_t xflen, uint8_t flgs, uint8_t lu, uint8_t cmdlen, uint8_t cmd) :
UHS_BULK_CommandBlockWrapperBase(tag, xflen, flgs),
bmCBWLUN(lu), bmReserved1(0), bmCBWCBLength(cmdlen), bmReserved2(0) {
for(int i = 0; i < 16; i++) CBWCB[i] = 0;
SCSI_CDB_BASE_t *x = reinterpret_cast<SCSI_CDB_BASE_t *>(CBWCB);
x->LUN = cmd;
}
// Wrap for CDB of 6
UHS_BULK_CommandBlockWrapper(uint32_t tag, uint32_t xflen, SCSI_CDB6_t *cdb, uint8_t dir) :
UHS_BULK_CommandBlockWrapperBase(tag, xflen, dir),
bmCBWLUN(cdb->LUN), bmReserved1(0), bmCBWCBLength(6), bmReserved2(0) {
memcpy(&CBWCB, cdb, 6);
}
// Wrap for CDB of 10
UHS_BULK_CommandBlockWrapper(uint32_t tag, uint32_t xflen, SCSI_CDB10_t *cdb, uint8_t dir) :
UHS_BULK_CommandBlockWrapperBase(tag, xflen, dir),
bmCBWLUN(cdb->LUN), bmReserved1(0), bmCBWCBLength(10), bmReserved2(0) {
memcpy(&CBWCB, cdb, 10);
}
} __attribute__((packed));
struct UHS_BULK_CommandStatusWrapper {
uint32_t dCSWSignature;
uint32_t dCSWTag;
uint32_t dCSWDataResidue;
uint8_t bCSWStatus;
} __attribute__((packed));
class UHS_Bulk_Storage : public UHS_USBInterface {
protected:
static const uint8_t epDataInIndex = 1; // DataIn endpoint index
static const uint8_t epDataOutIndex = 2; // DataOUT endpoint index
static const uint8_t epInterruptInIndex = 3; // InterruptIN endpoint index
uint8_t bMaxLUN; // Max LUN
volatile uint32_t dCBWTag; // Tag
volatile uint8_t bTheLUN; // Active LUN
volatile uint32_t CurrentCapacity[MASS_MAX_SUPPORTED_LUN]; // Total sectors
volatile uint16_t CurrentSectorSize[MASS_MAX_SUPPORTED_LUN]; // Sector size, clipped to 16 bits
volatile bool LUNOk[MASS_MAX_SUPPORTED_LUN]; // use this to check for media changes.
volatile bool WriteOk[MASS_MAX_SUPPORTED_LUN];
void PrintEndpointDescriptor(const USB_ENDPOINT_DESCRIPTOR* ep_ptr);
public:
UHS_Bulk_Storage(UHS_USB_HOST_BASE *p);
volatile UHS_EpInfo epInfo[MASS_MAX_ENDPOINTS];
uint8_t GetbMaxLUN(void) {
return bMaxLUN; // Max LUN
}
uint8_t GetbTheLUN(void) {
return bTheLUN; // Active LUN
}
bool WriteProtected(uint8_t lun);
uint8_t MediaCTL(uint8_t lun, uint8_t ctl);
uint8_t Read(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t blocks, uint8_t *buf);
uint8_t Write(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t blocks, const uint8_t *buf);
uint8_t LockMedia(uint8_t lun, uint8_t lock);
bool LUNIsGood(uint8_t lun);
uint32_t GetCapacity(uint8_t lun);
uint16_t GetSectorSize(uint8_t lun);
uint8_t SCSITransaction6(SCSI_CDB6_t *cdb, uint16_t buf_size, void *buf, uint8_t dir);
uint8_t SCSITransaction10(SCSI_CDB10_t *cdb, uint16_t buf_size, void *buf, uint8_t dir);
// Configure and internal methods, these should never be called by a user's sketch.
uint8_t Start(void);
bool OKtoEnumerate(ENUMERATION_INFO *ei);
uint8_t SetInterface(ENUMERATION_INFO *ei);
uint8_t GetAddress(void) {
return bAddress;
};
void Poll(void);
void DriverDefaults(void);
private:
void Reset(void);
void CheckMedia(void);
bool IsValidCBW(uint8_t size, uint8_t *pcbw);
bool IsMeaningfulCBW(uint8_t size, uint8_t *pcbw);
bool IsValidCSW(UHS_BULK_CommandStatusWrapper *pcsw, UHS_BULK_CommandBlockWrapperBase *pcbw);
bool CheckLUN(uint8_t lun);
uint8_t Inquiry(uint8_t lun, uint16_t size, uint8_t *buf);
uint8_t TestUnitReady(uint8_t lun);
uint8_t RequestSense(uint8_t lun, uint16_t size, uint8_t *buf);
uint8_t ModeSense6(uint8_t lun, uint8_t pc, uint8_t page, uint8_t subpage, uint8_t len, uint8_t *buf);
uint8_t GetMaxLUN(uint8_t *max_lun);
uint8_t SetCurLUN(uint8_t lun);
uint8_t ResetRecovery();
uint8_t ReadCapacity10(uint8_t lun, uint8_t *buf);
uint8_t Page3F(uint8_t lun);
uint8_t ClearEpHalt(uint8_t index);
uint8_t Transaction(UHS_BULK_CommandBlockWrapper *cbw, uint16_t bsize, void *buf);
uint8_t HandleUsbError(uint8_t error, uint8_t index);
uint8_t HandleSCSIError(uint8_t status);
};
#if defined(LOAD_UHS_BULK_STORAGE) && !defined(UHS_BULK_STORAGE_LOADED)
#include "UHS_BULK_STORAGE_INLINE.h"
#endif
#endif // __MASSTORAGE_H__

1210
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_BULK_STORAGE/UHS_BULK_STORAGE_INLINE.h Normal file
View file

@ -0,0 +1,1210 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if defined(LOAD_UHS_BULK_STORAGE) && defined(__UHS_BULK_STORAGE_H__) && !defined(UHS_BULK_STORAGE_LOADED)
#define UHS_BULK_STORAGE_LOADED
// uncomment to get 'printf' console debugging. NOT FOR UNO!
//#define DEBUG_PRINTF_EXTRA_HUGE_UHS_BULK_STORAGE
#if DEBUG_PRINTF_EXTRA_HUGE
#ifdef DEBUG_PRINTF_EXTRA_HUGE_UHS_BULK_STORAGE
#define BS_HOST_DEBUG(...) printf(__VA_ARGS__)
#else
#define BS_HOST_DEBUG(...) VOID0
#endif
#else
#define BS_HOST_DEBUG(...) VOID0
#endif
////////////////////////////////////////////////////////////////////////////////
// Interface code
////////////////////////////////////////////////////////////////////////////////
/**
* Get the capacity of the media
*
* @param lun Logical Unit Number
* @return media capacity
*/
uint32_t UHS_NI UHS_Bulk_Storage::GetCapacity(uint8_t lun) {
uint32_t v = 0LU;
pUsb->DisablePoll();
if(LUNOk[lun])
v = CurrentCapacity[lun];
pUsb->EnablePoll();
return v;
}
/**
* Get the sector (block) size used on the media
*
* @param lun Logical Unit Number
* @return media sector size
*/
uint16_t UHS_NI UHS_Bulk_Storage::GetSectorSize(uint8_t lun) {
uint16_t v = 0U;
pUsb->DisablePoll();
if(LUNOk[lun])
v = CurrentSectorSize[lun];
pUsb->EnablePoll();
return v;
}
/**
* Test if LUN is ready for use
*
* @param lun Logical Unit Number
* @return true if LUN is ready for use
*/
bool UHS_NI UHS_Bulk_Storage::LUNIsGood(uint8_t lun) {
bool v;
pUsb->DisablePoll();
v = LUNOk[lun];
pUsb->EnablePoll();
return v;
}
/**
* Test if LUN is write protected
*
* @param lun Logical Unit Number
* @return cached status of write protect switch
*/
bool UHS_NI UHS_Bulk_Storage::WriteProtected(uint8_t lun) {
bool v;
pUsb->DisablePoll();
v = WriteOk[lun];
pUsb->EnablePoll();
return v;
}
/**
* Wrap and execute a SCSI CDB with length of 6
*
* @param cdb CDB to execute
* @param buf_size Size of expected transaction
* @param buf Buffer
* @param dir MASS_CMD_DIR_IN | MASS_CMD_DIR_OUT
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::SCSITransaction6(SCSI_CDB6_t *cdb, uint16_t buf_size, void *buf, uint8_t dir) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
pUsb->DisablePoll();
// promote buf_size to 32bits.
UHS_BULK_CommandBlockWrapper cbw = UHS_BULK_CommandBlockWrapper(++dCBWTag, (uint32_t)buf_size, cdb, dir);
#if 0
// Lets check the CBW here:
printf("\r\n");
printf("\r\n");
uint8_t *dump = (uint8_t*)(&cbw);
for(int i=0; i<(sizeof (UHS_BULK_CommandBlockWrapper)); i++) {
printf("%02.2x ", *dump);
dump++;
}
printf("\r\n");
printf("\r\n");
#endif
uint8_t v = (HandleSCSIError(Transaction(&cbw, buf_size, buf)));
pUsb->EnablePoll();
return v;
}
/**
* Wrap and execute a SCSI CDB with length of 10
*
* @param cdb CDB to execute
* @param buf_size Size of expected transaction
* @param buf Buffer
* @param dir MASS_CMD_DIR_IN | MASS_CMD_DIR_OUT
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::SCSITransaction10(SCSI_CDB10_t *cdb, uint16_t buf_size, void *buf, uint8_t dir) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
pUsb->DisablePoll();
// promote buf_size to 32bits.
UHS_BULK_CommandBlockWrapper cbw = UHS_BULK_CommandBlockWrapper(++dCBWTag, (uint32_t)buf_size, cdb, dir);
//SetCurLUN(cdb->LUN);
uint8_t v = (HandleSCSIError(Transaction(&cbw, buf_size, buf)));
pUsb->EnablePoll();
return v;
}
/**
* Lock or Unlock the tray or door on device.
* Caution: Some devices with buggy firmware will lock up.
*
* @param lun Logical Unit Number
* @param lock 1 to lock, 0 to unlock
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::LockMedia(uint8_t lun, uint8_t lock) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
pUsb->DisablePoll();
Notify(PSTR("\r\nLockMedia\r\n"), 0x80);
Notify(PSTR("---------\r\n"), 0x80);
SCSI_CDB6_t cdb = SCSI_CDB6_t(SCSI_CMD_PREVENT_REMOVAL, lun, (uint8_t)0, lock);
uint8_t v = SCSITransaction6(&cdb, (uint16_t)0, NULL, (uint8_t)UHS_BULK_CMD_DIR_IN);
pUsb->EnablePoll();
return v;
}
/**
* Media control, for spindle motor and media tray or door.
* This includes CDROM, TAPE and anything with a media loader.
*
* @param lun Logical Unit Number
* @param ctl 0x00 Stop Motor, 0x01 Start Motor, 0x02 Eject Media, 0x03 Load Media
* @return 0 on success
*/
uint8_t UHS_NI UHS_Bulk_Storage::MediaCTL(uint8_t lun, uint8_t ctl) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
pUsb->DisablePoll();
Notify(PSTR("\r\nMediaCTL\r\n"), 0x80);
Notify(PSTR("-----------------\r\n"), 0x80);
uint8_t rcode = UHS_BULK_ERR_UNIT_NOT_READY;
if(bAddress) {
SCSI_CDB6_t cdb = SCSI_CDB6_t(SCSI_CMD_START_STOP_UNIT, lun, ctl & 0x03, 0);
rcode = SCSITransaction6(&cdb, (uint16_t)0, NULL, (uint8_t)UHS_BULK_CMD_DIR_OUT);
} else {
SetCurLUN(lun);
}
pUsb->EnablePoll();
return rcode;
}
/**
* Read data from media
*
* @param lun Logical Unit Number
* @param addr LBA address on media to read
* @param bsize size of a block (we should probably use the cached size)
* @param blocks how many blocks to read
* @param buf memory that is able to hold the requested data
* @return 0 on success
*/
uint8_t UHS_NI UHS_Bulk_Storage::Read(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t blocks, uint8_t *buf) {
if(!bAddress) return UHS_BULK_ERR_NO_MEDIA;
uint8_t er = UHS_BULK_ERR_NO_MEDIA;
pUsb->DisablePoll();
if(LUNOk[lun]) {
Notify(PSTR("\r\nRead LUN:\t"), 0x80);
D_PrintHex<uint8_t > (lun, 0x90);
Notify(PSTR("\r\nLBA:\t\t"), 0x90);
D_PrintHex<uint32_t > (addr, 0x90);
Notify(PSTR("\r\nblocks:\t\t"), 0x90);
D_PrintHex<uint8_t > (blocks, 0x90);
Notify(PSTR("\r\nblock size:\t"), 0x90);
D_PrintHex<uint16_t > (bsize, 0x90);
Notify(PSTR("\r\n---------\r\n"), 0x80);
SCSI_CDB10_t cdb = SCSI_CDB10_t(SCSI_CMD_READ_10, lun, blocks, addr);
again:
er = SCSITransaction10(&cdb, ((uint16_t)bsize * blocks), buf, (uint8_t)UHS_BULK_CMD_DIR_IN);
if(er == UHS_BULK_ERR_STALL) {
MediaCTL(lun, 1);
if(UHS_SLEEP_MS(150)) {
if(!TestUnitReady(lun)) goto again;
}
}
}
qNextPollTime = millis() + 100;
pUsb->EnablePoll();
return er;
}
/**
* Write data to media
*
* @param lun Logical Unit Number
* @param addr LBA address on media to write
* @param bsize size of a block (we should probably use the cached size)
* @param blocks how many blocks to write
* @param buf memory that contains the data to write
* @return 0 on success
*/
uint8_t UHS_NI UHS_Bulk_Storage::Write(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t blocks, const uint8_t * buf) {
if(!bAddress) return UHS_BULK_ERR_NO_MEDIA;
uint8_t er = UHS_BULK_ERR_NO_MEDIA;
pUsb->DisablePoll();
if(LUNOk[lun]) {
if(!WriteOk[lun]) {
er = UHS_BULK_ERR_WRITE_PROTECTED;
} else {
Notify(PSTR("\r\nWrite LUN:\t"), 0x80);
D_PrintHex<uint8_t > (lun, 0x90);
Notify(PSTR("\r\nLBA:\t\t"), 0x90);
D_PrintHex<uint32_t > (addr, 0x90);
Notify(PSTR("\r\nblocks:\t\t"), 0x90);
D_PrintHex<uint8_t > (blocks, 0x90);
Notify(PSTR("\r\nblock size:\t"), 0x90);
D_PrintHex<uint16_t > (bsize, 0x90);
Notify(PSTR("\r\n---------\r\n"), 0x80);
SCSI_CDB10_t cdb = SCSI_CDB10_t(SCSI_CMD_WRITE_10, lun, blocks, addr);
again:
er = SCSITransaction10(&cdb, ((uint16_t)bsize * blocks), (void*)buf, (uint8_t)UHS_BULK_CMD_DIR_OUT);
if(er == UHS_BULK_ERR_WRITE_STALL) {
MediaCTL(lun, 1);
if(UHS_SLEEP_MS(150)) {
if(!TestUnitReady(lun)) goto again;
}
}
}
}
qNextPollTime = millis() + 100;
pUsb->EnablePoll();
return er;
}
// End of user functions, the remaining code below is driver internals.
// Only developer serviceable parts below!
////////////////////////////////////////////////////////////////////////////////
// Main driver code
////////////////////////////////////////////////////////////////////////////////
UHS_NI UHS_Bulk_Storage::UHS_Bulk_Storage(UHS_USB_HOST_BASE *p) {
pUsb = p;
dCBWTag = 0;
if(pUsb) {
DriverDefaults();
pUsb->RegisterDeviceClass(this);
// Serial.print("Bulk Register to USB Host @ 0x");
// Serial.println((uint32_t)pUsb, HEX);
// Serial.print("Bulk Register to USB Host Address Pool @ 0x");
// Serial.println((uint32_t)pUsb->GetAddressPool(), HEX);
}
}
/**
*
* @param ei Enumeration information
* @return true if this interface driver can handle this interface description
*/
bool UHS_NI UHS_Bulk_Storage::OKtoEnumerate(ENUMERATION_INFO *ei) {
BS_HOST_DEBUG("BulkOnly: checking numep %i, klass %2.2x, subklass %2.2x\r\n", ei->interface.numep, ei->klass, ei->subklass);
BS_HOST_DEBUG("BulkOnly: checking protocol %2.2x, interface.klass %2.2x, interface.subklass %2.2x\r\n", ei->protocol, ei->interface.klass, ei->interface.subklass);
BS_HOST_DEBUG("BulkOnly: checking interface.protocol %2.2x\r\n", ei->interface.protocol);
//
// TO-DO?
// Check that we have 2 bulk endpoints, and one in each direction??
// e.g. (ei->interface.numep > 1) && // two or more endpoints AND check types
// This will work with proper hardware though.
//
return (
((ei->klass == UHS_USB_CLASS_MASS_STORAGE) || (ei->interface.klass == UHS_USB_CLASS_MASS_STORAGE)) && // mass storage class AND
((ei->subklass == UHS_BULK_SUBCLASS_SCSI) || (ei->interface.subklass == UHS_BULK_SUBCLASS_SCSI)) && // SCSI command set AND
((ei->protocol == UHS_STOR_PROTO_BBB) || (ei->interface.protocol == UHS_STOR_PROTO_BBB)) // Bulk Only transport
);
}
/**
* @param ei Enumeration information
* @return 0 always
*/
uint8_t UHS_NI UHS_Bulk_Storage::SetInterface(ENUMERATION_INFO *ei) {
uint8_t index;
bAddress = ei->address;
BS_HOST_DEBUG("BS SetInterface\r\n");
// Fill in the endpoint info structure
for(uint8_t ep = 0; ep < ei->interface.numep; ep++) {
BS_HOST_DEBUG("ep: 0x%2.2x bmAttributes: 0x%2.2x ", ep, ei->interface.epInfo[ep].bmAttributes);
if(ei->interface.epInfo[ep].bmAttributes == USB_TRANSFER_TYPE_BULK) {
index = ((ei->interface.epInfo[ep].bEndpointAddress & USB_TRANSFER_DIRECTION_IN) == USB_TRANSFER_DIRECTION_IN) ? epDataInIndex : epDataOutIndex;
epInfo[index].epAddr = (ei->interface.epInfo[ep].bEndpointAddress & 0x0F);
epInfo[index].maxPktSize = ei->interface.epInfo[ep].wMaxPacketSize;
epInfo[index].epAttribs = 0;
epInfo[index].bmNakPower = UHS_USB_NAK_MAX_POWER;
epInfo[index].bmSndToggle = 0;
epInfo[index].bmRcvToggle = 0;
epInfo[index].bIface=ei->interface.bInterfaceNumber;
BS_HOST_DEBUG("index: %i\r\n", index);
}
BS_HOST_DEBUG("\r\n");
}
bNumEP = 3;
epInfo[0].epAddr = 0;
epInfo[0].maxPktSize = ei->bMaxPacketSize0;
epInfo[0].bmNakPower = UHS_USB_NAK_MAX_POWER;
bIface = ei->interface.bInterfaceNumber;
return 0;
};
/**
*
* @return 0 for success
*/
uint8_t UHS_NI UHS_Bulk_Storage::Start(void) {
uint8_t rcode;
// Serial.print("Bulk Start from USB Host @ 0x");
// Serial.println((uint32_t)pUsb, HEX);
// Serial.print("Bulk Start USB Host Address Pool @ 0x");
// Serial.println((uint32_t)pUsb->GetAddressPool(), HEX);
BS_HOST_DEBUG("BS Start, speed: %i\r\n", pUsb->GetAddressPool()->GetUsbDevicePtr(bAddress)->speed);
BS_HOST_DEBUG("BS Start\r\n");
rcode = pUsb->setEpInfoEntry(bAddress, bIface, 3, epInfo);
// Serial.println(rcode,HEX);
if(rcode) goto FailOnInit;
// Do a 1 second delay before LUN query
if(!UHS_SLEEP_MS(1000)) goto FailUnPlug;
rcode = GetMaxLUN(&bMaxLUN);
BS_HOST_DEBUG("GetMaxLUN 0x%2.2x\r\n", rcode);
if(rcode) {
goto FailGetMaxLUN;
}
if(bMaxLUN >= MASS_MAX_SUPPORTED_LUN) bMaxLUN = MASS_MAX_SUPPORTED_LUN - 1;
BS_HOST_DEBUG("MaxLUN %u\r\n", bMaxLUN);
//ErrorMessage<uint8_t > (PSTR("MaxLUN"), bMaxLUN);
if(!UHS_SLEEP_MS(150)) goto FailUnPlug; // Delay a bit for slow firmware. (again)
for(uint8_t lun = 0; lun <= bMaxLUN; lun++) {
if(!UHS_SLEEP_MS(3)) goto FailUnPlug;
SCSI_Inquiry_Response response;
rcode = Inquiry(lun, sizeof (SCSI_Inquiry_Response), (uint8_t*) & response);
BS_HOST_DEBUG("Inquiry 0x%2.2x 0x%2.2x\r\n", sizeof (SCSI_Inquiry_Response), rcode);
if(rcode) {
goto FailInquiry;
#if 0
} else {
BS_HOST_DEBUG("LUN %i `", lun);
uint8_t *buf = response.VendorID;
for(int i = 0; i < 28; i++) BS_HOST_DEBUG("%c", buf[i]);
BS_HOST_DEBUG("'\r\nQualifier %1.1X ", response.PeripheralQualifier);
BS_HOST_DEBUG("Device type %2.2X ", response.DeviceType);
BS_HOST_DEBUG("RMB %1.1X ", response.Removable);
BS_HOST_DEBUG("SSCS %1.1X ", response.SCCS);
uint8_t sv = response.Version;
BS_HOST_DEBUG("SCSI version %2.2X\r\nDevice conforms to ", sv);
switch(sv) {
case 0:
BS_HOST_DEBUG("No specific");
break;
case 1:
BS_HOST_DEBUG("ANSI X3.131-1986 (ANSI 1)");
break;
case 2:
BS_HOST_DEBUG("ANSI X3.131-1994 (ANSI 2)");
break;
case 3:
BS_HOST_DEBUG("ANSI INCITS 301-1997 (SPC)");
break;
case 4:
BS_HOST_DEBUG("ANSI INCITS 351-2001 (SPC-2)");
break;
case 5:
BS_HOST_DEBUG("ANSI INCITS 408-2005 (SPC-4)");
break;
case 6:
BS_HOST_DEBUG("T10/1731-D (SPC-4)");
break;
default:
BS_HOST_DEBUG("unknown");
}
BS_HOST_DEBUG(" standards.\r\n");
#endif
}
}
for(uint8_t lun = 0; lun <= bMaxLUN; lun++) {
if(!UHS_SLEEP_MS(3)) goto FailUnPlug;
#ifndef USB_NO_TEST_UNIT_READY
uint8_t tries = 0xf0;
while((rcode = TestUnitReady(lun))) {
BS_HOST_DEBUG("\r\nTry %2.2x TestUnitReady %2.2x\r\n", tries - 0xf0, rcode);
if(rcode == 0x08) break; // break on no media, this is OK to do.
if(rcode == UHS_BULK_ERR_DEVICE_DISCONNECTED) goto FailUnPlug;
if(rcode == UHS_BULK_ERR_INVALID_CSW) goto Fail;
if(rcode != UHS_BULK_ERR_MEDIA_CHANGED) goto Fail;
if(!UHS_SLEEP_MS(2 * (tries + 1))) goto FailUnPlug;
tries++;
if(!tries) break;
}
#else
// Don't wait for the LUN to become ready, as this will
// trigger Marlin's watchdog timer
rcode = -1;
#endif
if(!UHS_SLEEP_MS(3)) goto FailUnPlug;
LockMedia(lun, 1);
if(rcode == 0x08) {
if(!UHS_SLEEP_MS(3)) goto FailUnPlug;
if(MediaCTL(lun, 1) == UHS_BULK_ERR_DEVICE_DISCONNECTED) goto FailUnPlug; // I actually have a USB stick that needs this!
}
BS_HOST_DEBUG("\r\nTry %2.2x TestUnitReady %2.2x\r\n", tries - 0xf0, rcode);
if(!rcode) {
if(!UHS_SLEEP_MS(3)) goto FailUnPlug;
BS_HOST_DEBUG("CheckLUN...\r\n");
BS_HOST_DEBUG("%lu\r\n", millis()/1000);
// Stalls on ***some*** devices, ***WHY***?! Device SAID it is READY!!
LUNOk[lun] = CheckLUN(lun);
BS_HOST_DEBUG("%lu\r\n", millis()/1000);
if(!LUNOk[lun]) LUNOk[lun] = CheckLUN(lun);
if(!UHS_SLEEP_MS(1)) goto FailUnPlug;
BS_HOST_DEBUG("Checked LUN...\r\n");
} else {
LUNOk[lun] = false;
}
}
rcode = OnStart();
if(rcode) goto FailOnInit;
#ifdef DEBUG_USB_HOST
USBTRACE("BS configured\r\n\r\n");
#endif
qNextPollTime = millis() + 100;
bPollEnable = true;
return 0;
FailUnPlug:
rcode = UHS_BULK_ERR_DEVICE_DISCONNECTED;
goto Fail;
FailOnInit:
#ifdef DEBUG_USB_HOST
USBTRACE("OnStart:");
goto Fail;
#endif
FailGetMaxLUN:
#ifdef DEBUG_USB_HOST
USBTRACE("GetMaxLUN:");
goto Fail;
#endif
FailInquiry:
#ifdef DEBUG_USB_HOST
USBTRACE("Inquiry:");
#endif
Fail:
#ifdef DEBUG_USB_HOST
NotifyFail(rcode);
#endif
Release();
return rcode;
}
// Base class definition of Release() used. See UHS_USBInterface class definition for details
/**
* For driver use only.
*
* @return
*/
//void UHS_NI UHS_Bulk_Storage::Release(void) {
// pUsb->DisablePoll();
// OnRelease();
// DriverDefaults();
// pUsb->EnablePoll();
// return;
//}
/**
* For driver use only.
*
* @param lun Logical Unit Number
* @return true if LUN is ready for use.
*/
bool UHS_NI UHS_Bulk_Storage::CheckLUN(uint8_t lun) {
uint8_t rcode;
SCSI_Capacity capacity;
for(uint8_t i = 0; i < 8; i++) capacity.data[i] = 0;
rcode = ReadCapacity10(lun, (uint8_t*)capacity.data);
if(rcode) {
BS_HOST_DEBUG(">>>>>>>>>>>>>>>>ReadCapacity returned %i\r\n", rcode);
return false;
}
#ifdef DEBUG_USB_HOST
ErrorMessage<uint8_t > (PSTR(">>>>>>>>>>>>>>>>CAPACITY OK ON LUN"), lun);
for(uint8_t i = 0; i < 8 /*sizeof (Capacity)*/; i++)
D_PrintHex<uint8_t > (capacity.data[i], 0x80);
Notify(PSTR("\r\n\r\n"), 0x80);
#endif
// Only 512/1024/2048/4096 are valid values!
uint32_t c = UHS_BYTES_TO_UINT32(capacity.data[4], capacity.data[5], capacity.data[6], capacity.data[7]);
if(c != 0x0200LU && c != 0x0400LU && c != 0x0800LU && c != 0x1000LU) {
return false;
}
// Store capacity information.
CurrentSectorSize[lun] = (uint16_t)(c); // & 0xFFFF);
CurrentCapacity[lun] = UHS_BYTES_TO_UINT32(capacity.data[0], capacity.data[1], capacity.data[2], capacity.data[3]) + 1;
if(CurrentCapacity[lun] == /*0xffffffffLU */ 0x01LU || CurrentCapacity[lun] == 0x00LU) {
// Buggy firmware will report 0xffffffff or 0 for no media
#ifdef DEBUG_USB_HOST
if(CurrentCapacity[lun])
ErrorMessage<uint8_t > (PSTR(">>>>>>>>>>>>>>>>BUGGY FIRMWARE. CAPACITY FAIL ON LUN"), lun);
#endif
return false;
}
if(!UHS_SLEEP_MS(20)) return false;
#ifndef SKIP_PAGE3F
Page3F(lun);
#endif
if(!TestUnitReady(lun)) return true;
return false;
}
/**
* For driver use only.
*
* Scan for media change on all LUNs
*/
void UHS_NI UHS_Bulk_Storage::CheckMedia(void) {
if(!bAddress) return;
for(uint8_t lun = 0; lun <= bMaxLUN; lun++) {
if(TestUnitReady(lun)) {
LUNOk[lun] = false;
continue;
}
if(!LUNOk[lun])
LUNOk[lun] = CheckLUN(lun);
}
#if 0
BS_HOST_DEBUG("}}}}}}}}}}}}}}}}STATUS ");
for(uint8_t lun = 0; lun <= bMaxLUN; lun++) {
if(LUNOk[lun])
BS_HOST_DEBUG("#");
else BS_HOST_DEBUG(".");
}
BS_HOST_DEBUG("\r\n");
#endif
OnPoll();
qNextPollTime = millis() + 100;
}
/**
* For driver use only.
*
*/
void UHS_NI UHS_Bulk_Storage::Poll(void) {
if((long)(millis() - qNextPollTime) >= 0L) {
CheckMedia();
}
return;
}
////////////////////////////////////////////////////////////////////////////////
// SCSI code
////////////////////////////////////////////////////////////////////////////////
/**
* For driver use only.
*
* @param plun
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::GetMaxLUN(uint8_t *plun) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
uint8_t ret = pUsb->ctrlReq(bAddress, mkSETUP_PKT16(UHS_BULK_bmREQ_IN, UHS_BULK_REQ_GET_MAX_LUN, 0x0000U, bIface, 1), 1, plun);
if(ret == UHS_HOST_ERROR_STALL) {
*plun = 0;
Notify(PSTR("\r\nGetMaxLUN Stalled\r\n"), 0x80);
}
return 0;
}
/**
* For driver use only. Used during Driver Start
*
* @param lun Logical Unit Number
* @param bsize
* @param buf
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::Inquiry(uint8_t lun, uint16_t bsize, uint8_t *buf) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
Notify(PSTR("\r\nInquiry\r\n"), 0x80);
Notify(PSTR("---------\r\n"), 0x80);
SCSI_CDB6_t cdb = SCSI_CDB6_t(SCSI_CMD_INQUIRY, lun, 0LU, (uint8_t)bsize, 0);
uint8_t rc = SCSITransaction6(&cdb, bsize, buf, (uint8_t)UHS_BULK_CMD_DIR_IN);
return rc;
}
/**
* For driver use only.
*
* @param lun Logical Unit Number
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::TestUnitReady(uint8_t lun) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
//SetCurLUN(lun);
if(!bAddress)
return UHS_BULK_ERR_UNIT_NOT_READY;
Notify(PSTR("\r\nTestUnitReady\r\n"), 0x80);
Notify(PSTR("-----------------\r\n"), 0x80);
SCSI_CDB6_t cdb = SCSI_CDB6_t(SCSI_CMD_TEST_UNIT_READY, lun, (uint8_t)0, 0);
return SCSITransaction6(&cdb, 0, NULL, (uint8_t)UHS_BULK_CMD_DIR_IN);
}
/**
* For driver use only.
*
* @param lun Logical Unit Number
* @param pc
* @param page
* @param subpage
* @param len
* @param pbuf
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::ModeSense6(uint8_t lun, uint8_t pc, uint8_t page, uint8_t subpage, uint8_t len, uint8_t * pbuf) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
Notify(PSTR("\r\rModeSense\r\n"), 0x80);
Notify(PSTR("------------\r\n"), 0x80);
SCSI_CDB6_t cdb = SCSI_CDB6_t(SCSI_CMD_MODE_SENSE_6, lun, (uint32_t)((((pc << 6) | page) << 8) | subpage), len, 0);
return SCSITransaction6(&cdb, len, pbuf, (uint8_t)UHS_BULK_CMD_DIR_IN);
}
/**
* For driver use only.
*
* @param lun Logical Unit Number
* @param bsize
* @param buf
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::ReadCapacity10(uint8_t lun, uint8_t *buf) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
Notify(PSTR("\r\nReadCapacity\r\n"), 0x80);
Notify(PSTR("---------------\r\n"), 0x80);
SCSI_CDB10_t cdb = SCSI_CDB10_t(SCSI_CMD_READ_CAPACITY_10, lun);
return SCSITransaction10(&cdb, 8, buf, (uint8_t)UHS_BULK_CMD_DIR_IN);
}
/**
* For driver use only.
*
* Page 3F contains write protect status.
*
* @param lun Logical Unit Number to test.
* @return Write protect switch status.
*/
uint8_t UHS_NI UHS_Bulk_Storage::Page3F(uint8_t lun) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
uint8_t buf[192];
for(int i = 0; i < 192; i++) {
buf[i] = 0x00;
}
WriteOk[lun] = true;
uint8_t rc = ModeSense6(lun, 0, 0x3f, 0, 192, buf);
if(!rc) {
WriteOk[lun] = ((buf[2] & 0x80) == 0);
#ifdef DEBUG_USB_HOST
Notify(PSTR("Mode Sense: "), 0x80);
for(int i = 0; i < 4; i++) {
D_PrintHex<uint8_t > (buf[i], 0x80);
Notify(PSTR(" "), 0x80);
}
Notify(PSTR("\r\n"), 0x80);
#endif
}
return rc;
}
/**
* For driver use only.
*
* @param lun Logical Unit Number
* @param size
* @param buf
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::RequestSense(uint8_t lun, uint16_t size, uint8_t *buf) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
pUsb->DisablePoll();
Notify(PSTR("\r\nRequestSense\r\n"), 0x80);
Notify(PSTR("----------------\r\n"), 0x80);
SCSI_CDB6_t cdb = SCSI_CDB6_t(SCSI_CMD_REQUEST_SENSE, lun, 0LU, (uint8_t)size, 0);
UHS_BULK_CommandBlockWrapper cbw = UHS_BULK_CommandBlockWrapper(++dCBWTag, (uint32_t)size, &cdb, (uint8_t)UHS_BULK_CMD_DIR_IN);
uint8_t v = Transaction(&cbw, size, buf);
pUsb->EnablePoll();
return v;
}
////////////////////////////////////////////////////////////////////////////////
// USB code
////////////////////////////////////////////////////////////////////////////////
/**
* For driver use only.
*
* @param index
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::ClearEpHalt(uint8_t index) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
uint8_t ret = 0;
if(index != 0) {
uint8_t ep = (index == epDataInIndex) ? (0x80 | epInfo[index].epAddr) : epInfo[index].epAddr;
do {
ret = pUsb->EPClearHalt(bAddress, ep);
if(!UHS_SLEEP_MS(6)) break;
} while(ret == 0x01);
if(ret) {
ErrorMessage<uint8_t > (PSTR("ClearEpHalt"), ret);
ErrorMessage<uint8_t > (PSTR("EP"), ep);
epInfo[index].bmSndToggle = 0;
epInfo[index].bmRcvToggle = 0;
return ret;
} else {
epInfo[index].bmSndToggle = 0;
epInfo[index].bmRcvToggle = 0;
}
}
return ret;
}
/**
* For driver use only.
*
*/
void UHS_NI UHS_Bulk_Storage::Reset(void) {
if(!bAddress) return;
while(pUsb->ctrlReq(bAddress, mkSETUP_PKT16(UHS_BULK_bmREQ_OUT, UHS_BULK_REQ_BOMSR, 0x0000U, bIface, 0), 0, NULL) == 0x01) {
if(!UHS_SLEEP_MS(6)) break;
}
if(!bAddress) return;
UHS_SLEEP_MS(2500);
}
/**
* For driver use only.
*
* @return 0 if successful
*/
uint8_t UHS_NI UHS_Bulk_Storage::ResetRecovery(void) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
Notify(PSTR("\r\nResetRecovery\r\n"), 0x80);
Notify(PSTR("-----------------\r\n"), 0x80);
qNextPollTime = millis() + 90000;
uint8_t bLastUsbError = UHS_HOST_ERROR_UNPLUGGED;
if(UHS_SLEEP_MS(6)) {
Reset();
if(UHS_SLEEP_MS(6)) {
bLastUsbError = ClearEpHalt(epDataInIndex);
if(UHS_SLEEP_MS(6)) {
bLastUsbError = ClearEpHalt(epDataOutIndex);
UHS_SLEEP_MS(6);
}
}
}
return bLastUsbError;
}
/**
* For driver use only.
*
* Clear all EP data and clear all LUN status
*/
void UHS_NI UHS_Bulk_Storage::DriverDefaults(void) {
pUsb->DeviceDefaults(MASS_MAX_ENDPOINTS, this);
for(uint8_t i = 0; i < MASS_MAX_SUPPORTED_LUN; i++) {
LUNOk[i] = false;
WriteOk[i] = false;
CurrentCapacity[i] = 0lu;
CurrentSectorSize[i] = 0;
}
dCBWTag = 0;
bMaxLUN = 0;
bTheLUN = 0;
}
/**
* For driver use only.
*
* @param pcsw
* @param pcbw
* @return
*/
bool UHS_NI UHS_Bulk_Storage::IsValidCSW(UHS_BULK_CommandStatusWrapper *pcsw, UHS_BULK_CommandBlockWrapperBase *pcbw) {
if(!bAddress) return false;
if(pcsw->dCSWSignature != UHS_BULK_CSW_SIGNATURE) {
Notify(PSTR("CSW:Sig error\r\n"), 0x80);
return false;
}
if(pcsw->dCSWTag != pcbw->dCBWTag) {
Notify(PSTR("CSW:Wrong tag\r\n"), 0x80);
ErrorMessage<uint32_t > (PSTR("dCSWTag"), pcsw->dCSWTag);
ErrorMessage<uint32_t > (PSTR("dCBWTag"), pcbw->dCBWTag);
return false;
}
return true;
}
/**
* For driver use only.
*
* @param error
* @param index
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::HandleUsbError(uint8_t error, uint8_t index) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
uint8_t count = 3;
while(error && count) {
if(error != UHS_HOST_ERROR_NONE) {
ErrorMessage<uint8_t > (PSTR("USB Error"), error);
ErrorMessage<uint8_t > (PSTR("Index"), index);
}
switch(error) {
// case UHS_HOST_ERROR_WRONGPID:
case UHS_HOST_ERROR_NONE:
return UHS_BULK_ERR_SUCCESS;
case UHS_HOST_ERROR_BUSY:
// SIE is busy, just hang out and try again.
return UHS_BULK_ERR_UNIT_BUSY;
case UHS_HOST_ERROR_NAK:
return UHS_BULK_ERR_UNIT_BUSY;
case UHS_HOST_ERROR_UNPLUGGED:
case UHS_HOST_ERROR_TIMEOUT:
case UHS_HOST_ERROR_JERR:
return UHS_BULK_ERR_DEVICE_DISCONNECTED;
case UHS_HOST_ERROR_STALL:
if(index == 0) return UHS_BULK_ERR_STALL;
ClearEpHalt(index);
if(index != epDataInIndex) return UHS_BULK_ERR_WRITE_STALL;
return UHS_BULK_ERR_STALL;
case UHS_HOST_ERROR_TOGERR:
// Handle a very super rare corner case, where toggles become de-synched.
// I have only ran into one device that has this firmware bug, and this is
// the only clean way to get back into sync with the buggy device firmware.
// --AJK
if(bAddress && bConfNum) {
error = pUsb->setConf(bAddress, bConfNum);
if(error) break;
}
return UHS_BULK_ERR_SUCCESS;
default:
ErrorMessage<uint8_t > (PSTR("\r\nUSB"), error);
return UHS_BULK_ERR_GENERAL_USB_ERROR;
}
count--;
} // while
return ((error && !count) ? UHS_BULK_ERR_GENERAL_USB_ERROR : UHS_BULK_ERR_SUCCESS);
}
/**
* For driver use only.
*
* @param pcbw
* @param buf_size
* @param buf
* @param flags
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::Transaction(UHS_BULK_CommandBlockWrapper *pcbw, uint16_t buf_size, void *buf) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
uint16_t bytes = buf_size;
bool write = (pcbw->bmCBWFlags & UHS_BULK_CMD_DIR_IN) != UHS_BULK_CMD_DIR_IN;
uint8_t ret = 0;
uint8_t usberr;
UHS_BULK_CommandStatusWrapper csw; // up here, we allocate ahead to save cpu cycles.
SetCurLUN(pcbw->bmCBWLUN);
ErrorMessage<uint32_t > (PSTR("CBW.dCBWTag"), pcbw->dCBWTag);
while((usberr = pUsb->outTransfer(bAddress, epInfo[epDataOutIndex].epAddr, sizeof (UHS_BULK_CommandBlockWrapper), (uint8_t*)pcbw)) == UHS_HOST_ERROR_BUSY) {
if(!UHS_SLEEP_MS(1)) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
}
ret = HandleUsbError(usberr, epDataOutIndex);
if(ret) {
ErrorMessage<uint8_t > (PSTR("============================ CBW"), ret);
} else {
if(bytes) {
if(!write) {
while((usberr = pUsb->inTransfer(bAddress, epInfo[epDataInIndex].epAddr, &bytes, (uint8_t*)buf)) == UHS_HOST_ERROR_BUSY) {
if(!UHS_SLEEP_MS(1)) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
}
ret = HandleUsbError(usberr, epDataInIndex);
} else {
while((usberr = pUsb->outTransfer(bAddress, epInfo[epDataOutIndex].epAddr, bytes, (uint8_t*)buf)) == UHS_HOST_ERROR_BUSY) {
if(!UHS_SLEEP_MS(1)) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
}
ret = HandleUsbError(usberr, epDataOutIndex);
}
if(ret) {
ErrorMessage<uint8_t > (PSTR("============================ DAT"), ret);
}
}
}
{
bytes = sizeof (UHS_BULK_CommandStatusWrapper);
int tries = 2;
while(tries--) {
while((usberr = pUsb->inTransfer(bAddress, epInfo[epDataInIndex].epAddr, &bytes, (uint8_t*) & csw)) == UHS_HOST_ERROR_BUSY) {
if(!UHS_SLEEP_MS(1)) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
}
if(!usberr) break;
if(tries) {
if(usberr == UHS_HOST_ERROR_STALL) {
ResetRecovery();
} else {
ClearEpHalt(epDataInIndex);
}
}
}
if(!ret) {
Notify(PSTR("CBW:\t\tOK\r\n"), 0x80);
Notify(PSTR("Data Stage:\tOK\r\n"), 0x80);
} else {
// Throw away csw, IT IS NOT OF ANY USE.
ResetRecovery();
return ret;
}
ret = HandleUsbError(usberr, epDataInIndex);
if(ret) {
ErrorMessage<uint8_t > (PSTR("============================ CSW"), ret);
}
if(usberr == UHS_HOST_ERROR_NONE) {
if(IsValidCSW(&csw, pcbw)) {
//ErrorMessage<uint32_t > (PSTR("CSW.dCBWTag"), csw.dCSWTag);
//ErrorMessage<uint8_t > (PSTR("bCSWStatus"), csw.bCSWStatus);
//ErrorMessage<uint32_t > (PSTR("dCSWDataResidue"), csw.dCSWDataResidue);
Notify(PSTR("CSW:\t\tOK\r\n\r\n"), 0x80);
return csw.bCSWStatus;
} else {
// NOTE! Sometimes this is caused by the reported residue being wrong.
// Get a different device. It isn't compliant, and should have never passed Q&A.
// I own one... 05e3:0701 Genesys Logic, Inc. USB 2.0 IDE Adapter.
// Other devices that exhibit this behavior exist in the wild too.
// Be sure to check quirks in the Linux source code before reporting a bug. --xxxajk
Notify(PSTR("Invalid CSW\r\n"), 0x80);
Reset();
ResetRecovery();
return UHS_BULK_ERR_INVALID_CSW;
}
}
}
return ret;
}
/**
* For driver use only.
*
* @param lun Logical Unit Number
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::SetCurLUN(uint8_t lun) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
if(lun > bMaxLUN)
return UHS_BULK_ERR_INVALID_LUN;
bTheLUN = lun;
return UHS_BULK_ERR_SUCCESS;
};
/**
* For driver use only.
*
* @param status
* @return
*/
uint8_t UHS_NI UHS_Bulk_Storage::HandleSCSIError(uint8_t status) {
if(!bAddress) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
uint8_t ret = 0;
switch(status) {
case 0: return UHS_BULK_ERR_SUCCESS;
case 2:
ErrorMessage<uint8_t > (PSTR("Phase Error"), status);
ErrorMessage<uint8_t > (PSTR("LUN"), bTheLUN);
ResetRecovery();
return UHS_BULK_ERR_GENERAL_SCSI_ERROR;
case 1:
ErrorMessage<uint8_t > (PSTR("SCSI Error"), status);
ErrorMessage<uint8_t > (PSTR("LUN"), bTheLUN);
SCSI_Request_Sense_Response rsp;
ret = RequestSense(bTheLUN, sizeof (SCSI_Request_Sense_Response), (uint8_t*) & rsp);
if(ret) {
if(ret == UHS_BULK_ERR_DEVICE_DISCONNECTED) return UHS_BULK_ERR_DEVICE_DISCONNECTED;
return UHS_BULK_ERR_GENERAL_SCSI_ERROR;
}
#if ENABLE_UHS_DEBUGGING
ErrorMessage<uint8_t > (PSTR("Response Code"), rsp.bResponseCode);
if(rsp.bResponseCode & 0x80) {
Notify(PSTR("Information field: "), 0x80);
for(int i = 0; i < 4; i++) {
D_PrintHex<uint8_t > (rsp.CmdSpecificInformation[i], 0x80);
Notify(PSTR(" "), 0x80);
}
Notify(PSTR("\r\n"), 0x80);
}
ErrorMessage<uint8_t > (PSTR("Sense Key"), rsp.bmSenseKey);
ErrorMessage<uint8_t > (PSTR("Add Sense Code"), rsp.bAdditionalSenseCode);
ErrorMessage<uint8_t > (PSTR("Add Sense Qual"), rsp.bAdditionalSenseQualifier);
#endif
// warning, this is not testing ASQ, only SK and ASC.
switch(rsp.bmSenseKey) {
case SCSI_S_UNIT_ATTENTION:
switch(rsp.bAdditionalSenseCode) {
case SCSI_ASC_MEDIA_CHANGED:
return UHS_BULK_ERR_MEDIA_CHANGED;
default:
return UHS_BULK_ERR_UNIT_NOT_READY;
}
case SCSI_S_NOT_READY:
switch(rsp.bAdditionalSenseCode) {
case SCSI_ASC_MEDIUM_NOT_PRESENT:
return UHS_BULK_ERR_NO_MEDIA;
default:
return UHS_BULK_ERR_UNIT_NOT_READY;
}
case SCSI_S_ILLEGAL_REQUEST:
switch(rsp.bAdditionalSenseCode) {
case SCSI_ASC_LBA_OUT_OF_RANGE:
return UHS_BULK_ERR_BAD_LBA;
default:
return UHS_BULK_ERR_CMD_NOT_SUPPORTED;
}
default:
return UHS_BULK_ERR_GENERAL_SCSI_ERROR;
}
// case 4: return MASS_ERR_UNIT_BUSY; // Busy means retry later.
// case 0x05/0x14: we stalled out
// case 0x15/0x16: we naked out.
default:
ErrorMessage<uint8_t > (PSTR("Gen SCSI Err"), status);
ErrorMessage<uint8_t > (PSTR("LUN"), bTheLUN);
return status;
} // switch
}
////////////////////////////////////////////////////////////////////////////////
// Debugging code
////////////////////////////////////////////////////////////////////////////////
/**
*
* @param ep_ptr
*/
void UHS_NI UHS_Bulk_Storage::PrintEndpointDescriptor(const USB_ENDPOINT_DESCRIPTOR * ep_ptr) {
Notify(PSTR("Endpoint descriptor:"), 0x80);
Notify(PSTR("\r\nLength:\t\t"), 0x80);
D_PrintHex<uint8_t > (ep_ptr->bLength, 0x80);
Notify(PSTR("\r\nType:\t\t"), 0x80);
D_PrintHex<uint8_t > (ep_ptr->bDescriptorType, 0x80);
Notify(PSTR("\r\nAddress:\t"), 0x80);
D_PrintHex<uint8_t > (ep_ptr->bEndpointAddress, 0x80);
Notify(PSTR("\r\nAttributes:\t"), 0x80);
D_PrintHex<uint8_t > (ep_ptr->bmAttributes, 0x80);
Notify(PSTR("\r\nMaxPktSize:\t"), 0x80);
D_PrintHex<uint16_t > (ep_ptr->wMaxPacketSize, 0x80);
Notify(PSTR("\r\nPoll Intrv:\t"), 0x80);
D_PrintHex<uint8_t > (ep_ptr->bInterval, 0x80);
Notify(PSTR("\r\n"), 0x80);
}
#else
#error "Never include UHS_BULK_STORAGE_INLINE.h, include UHS_host.h instead"
#endif

328
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_BULK_STORAGE/UHS_SCSI.h Normal file
View file

@ -0,0 +1,328 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#ifndef UHS_SCSI_H
#define UHS_SCSI_H
/*
* Reference documents from T10 (http://www.t10.org)
* SCSI Primary Commands - 3 (SPC-3)
* SCSI Block Commands - 2 (SBC-2)
* Multi-Media Commands - 5 (MMC-5)
*/
/* Group 1 commands (CDB's here are should all be 6-bytes) */
#define SCSI_CMD_TEST_UNIT_READY 0x00U
#define SCSI_CMD_REQUEST_SENSE 0x03U
#define SCSI_CMD_FORMAT_UNIT 0x04U
#define SCSI_CMD_READ_6 0x08U
#define SCSI_CMD_WRITE_6 0x0AU
#define SCSI_CMD_INQUIRY 0x12U
#define SCSI_CMD_MODE_SELECT_6 0x15U
#define SCSI_CMD_MODE_SENSE_6 0x1AU
#define SCSI_CMD_START_STOP_UNIT 0x1BU
#define SCSI_CMD_PREVENT_REMOVAL 0x1EU
/* Group 2 Commands (CDB's here are 10-bytes) */
#define SCSI_CMD_READ_FORMAT_CAPACITIES 0x23U
#define SCSI_CMD_READ_CAPACITY_10 0x25U
#define SCSI_CMD_READ_10 0x28U
#define SCSI_CMD_WRITE_10 0x2AU
#define SCSI_CMD_SEEK_10 0x2BU
#define SCSI_CMD_ERASE_10 0x2CU
#define SCSI_CMD_WRITE_AND_VERIFY_10 0x2EU
#define SCSI_CMD_VERIFY_10 0x2FU
#define SCSI_CMD_SYNCHRONIZE_CACHE 0x35U
#define SCSI_CMD_WRITE_BUFFER 0x3BU
#define SCSI_CMD_READ_BUFFER 0x3CU
#define SCSI_CMD_READ_SUBCHANNEL 0x42U
#define SCSI_CMD_READ_TOC 0x43U
#define SCSI_CMD_READ_HEADER 0x44U
#define SCSI_CMD_PLAY_AUDIO_10 0x45U
#define SCSI_CMD_GET_CONFIGURATION 0x46U
#define SCSI_CMD_PLAY_AUDIO_MSF 0x47U
#define SCSI_CMD_PLAY_AUDIO_TI 0x48U
#define SCSI_CMD_PLAY_TRACK_REL_10 0x49U
#define SCSI_CMD_GET_EVENT_STATUS 0x4AU
#define SCSI_CMD_PAUSE_RESUME 0x4BU
#define SCSI_CMD_READ_DISC_INFORMATION 0x51U
#define SCSI_CMD_READ_TRACK_INFORMATION 0x52U
#define SCSI_CMD_RESERVE_TRACK 0x53U
#define SCSI_CMD_SEND_OPC_INFORMATION 0x54U
#define SCSI_CMD_MODE_SELECT_10 0x55U
#define SCSI_CMD_REPAIR_TRACK 0x58U
#define SCSI_CMD_MODE_SENSE_10 0x5AU
#define SCSI_CMD_CLOSE_TRACK_SESSION 0x5BU
#define SCSI_CMD_READ_BUFFER_CAPACITY 0x5CU
#define SCSI_CMD_SEND_CUE_SHEET 0x5DU
/* Group 5 Commands (CDB's here are 12-bytes) */
#define SCSI_CMD_REPORT_LUNS 0xA0U
#define SCSI_CMD_BLANK 0xA1U
#define SCSI_CMD_SECURITY_PROTOCOL_IN 0xA2U
#define SCSI_CMD_SEND_KEY 0xA3U
#define SCSI_CMD_REPORT_KEY 0xA4U
#define SCSI_CMD_PLAY_AUDIO_12 0xA5U
#define SCSI_CMD_LOAD_UNLOAD 0xA6U
#define SCSI_CMD_SET_READ_AHEAD 0xA7U
#define SCSI_CMD_READ_12 0xA8U
#define SCSI_CMD_PLAY_TRACK_REL_12 0xA9U
#define SCSI_CMD_WRITE_12 0xAAU
#define SCSI_CMD_READ_MEDIA_SERIAL_12 0xABU
#define SCSI_CMD_GET_PERFORMANCE 0xACU
#define SCSI_CMD_READ_DVD_STRUCTURE 0xADU
#define SCSI_CMD_SECURITY_PROTOCOL_OUT 0xB5U
#define SCSI_CMD_SET_STREAMING 0xB6U
#define SCSI_CMD_READ_MSF 0xB9U
#define SCSI_CMD_SET_SPEED 0xBBU
#define SCSI_CMD_MECHANISM_STATUS 0xBDU
#define SCSI_CMD_READ_CD 0xBEU
#define SCSI_CMD_SEND_DISC_STRUCTURE 0xBFU
/* Vendor-unique Commands, included for completeness */
#define SCSI_CMD_CD_PLAYBACK_STATUS 0xC4U /* SONY unique */
#define SCSI_CMD_PLAYBACK_CONTROL 0xC9U /* SONY unique */
#define SCSI_CMD_READ_CDDA 0xD8U /* Vendor unique */
#define SCSI_CMD_READ_CDXA 0xDBU /* Vendor unique */
#define SCSI_CMD_READ_ALL_SUBCODES 0xDFU /* Vendor unique */
/* SCSI error codes */
#define SCSI_S_NOT_READY 0x02U
#define SCSI_S_MEDIUM_ERROR 0x03U
#define SCSI_S_ILLEGAL_REQUEST 0x05U
#define SCSI_S_UNIT_ATTENTION 0x06U
#define SCSI_ASC_LBA_OUT_OF_RANGE 0x21U
#define SCSI_ASC_MEDIA_CHANGED 0x28U
#define SCSI_ASC_MEDIUM_NOT_PRESENT 0x3AU
struct SCSI_Capacity {
uint8_t data[8];
//uint32_t dwBlockAddress;
//uint32_t dwBlockLength;
} __attribute__((packed));
struct SCSI_CDB_BASE {
uint8_t Opcode;
unsigned unused : 5;
unsigned LUN : 3;
uint8_t info[12];
} __attribute__((packed));
typedef SCSI_CDB_BASE SCSI_CDB_BASE_t;
struct SCSI_CDB6 {
uint8_t Opcode;
unsigned LBAMSB : 5;
unsigned LUN : 3;
uint8_t LBAHB;
uint8_t LBALB;
uint8_t AllocationLength;
uint8_t Control;
public:
SCSI_CDB6(uint8_t _Opcode, uint8_t _LUN, uint32_t LBA, uint8_t _AllocationLength, uint8_t _Control) :
Opcode(_Opcode), LBAMSB(UHS_UINT8_BYTE2(LBA) & 0x1f), LUN(_LUN), LBAHB(UHS_UINT8_BYTE1(LBA)), LBALB(UHS_UINT8_BYTE0(LBA)),
AllocationLength(_AllocationLength), Control(_Control) {
}
SCSI_CDB6(uint8_t _Opcode, uint8_t _LUN, uint8_t _AllocationLength, uint8_t _Control) :
Opcode(_Opcode), LBAMSB(0), LUN(_LUN), LBAHB(0), LBALB(0),
AllocationLength(_AllocationLength), Control(_Control) {
}
} __attribute__((packed));
typedef SCSI_CDB6 SCSI_CDB6_t;
struct SCSI_CDB10 {
uint8_t Opcode;
unsigned Service_Action : 5;
unsigned LUN : 3;
uint8_t LBA_L_M_MB;
uint8_t LBA_L_M_LB;
uint8_t LBA_L_L_MB;
uint8_t LBA_L_L_LB;
uint8_t Misc2;
uint8_t ALC_MB;
uint8_t ALC_LB;
uint8_t Control;
public:
SCSI_CDB10(uint8_t _Opcode, uint8_t _LUN) :
Opcode(_Opcode), Service_Action(0), LUN(_LUN),
LBA_L_M_MB(0), LBA_L_M_LB(0), LBA_L_L_MB(0), LBA_L_L_LB(0),
Misc2(0), ALC_MB(0), ALC_LB(0), Control(0) {
}
SCSI_CDB10(uint8_t _Opcode, uint8_t _LUN, uint16_t xflen, uint32_t _LBA) :
Opcode(_Opcode), Service_Action(0), LUN(_LUN),
LBA_L_M_MB(UHS_UINT8_BYTE3(_LBA)), LBA_L_M_LB(UHS_UINT8_BYTE2(_LBA)), LBA_L_L_MB(UHS_UINT8_BYTE1(_LBA)), LBA_L_L_LB(UHS_UINT8_BYTE0(_LBA)),
Misc2(0), ALC_MB(UHS_UINT8_BYTE1(xflen)), ALC_LB(UHS_UINT8_BYTE0(xflen)), Control(0) {
}
} __attribute__((packed));
typedef SCSI_CDB10 SCSI_CDB10_t;
struct SCSI_CDB12 {
uint8_t Opcode;
unsigned Service_Action : 5;
unsigned Misc : 3;
uint8_t LBA_L_M_LB;
uint8_t LBA_L_L_MB;
uint8_t LBA_L_L_LB;
uint8_t ALC_M_LB;
uint8_t ALC_L_MB;
uint8_t ALC_L_LB;
uint8_t Control;
} __attribute__((packed));
typedef SCSI_CDB12 SCSI_CDB12_t;
struct SCSI_CDB_LBA32_16 {
uint8_t Opcode;
unsigned Service_Action : 5;
unsigned Misc : 3;
uint8_t LBA_L_M_MB;
uint8_t LBA_L_M_LB;
uint8_t LBA_L_L_MB;
uint8_t LBA_L_L_LB;
uint8_t A_M_M_MB;
uint8_t A_M_M_LB;
uint8_t A_M_L_MB;
uint8_t A_M_L_LB;
uint8_t ALC_M_MB;
uint8_t ALC_M_LB;
uint8_t ALC_L_MB;
uint8_t ALC_L_LB;
uint8_t Misc2;
uint8_t Control;
} __attribute__((packed));
struct SCSI_CDB_LBA64_16 {
uint8_t Opcode;
uint8_t Misc;
uint8_t LBA_M_M_MB;
uint8_t LBA_M_M_LB;
uint8_t LBA_M_L_MB;
uint8_t LBA_M_L_LB;
uint8_t LBA_L_M_MB;
uint8_t LBA_L_M_LB;
uint8_t LBA_L_L_MB;
uint8_t LBA_L_L_LB;
uint8_t ALC_M_MB;
uint8_t ALC_M_LB;
uint8_t ALC_L_MB;
uint8_t ALC_L_LB;
uint8_t Misc2;
uint8_t Control;
} __attribute__((packed));
struct SCSI_Inquiry_Response {
uint8_t DeviceType : 5;
uint8_t PeripheralQualifier : 3;
unsigned Reserved : 7;
unsigned Removable : 1;
uint8_t Version;
unsigned ResponseDataFormat : 4;
unsigned HISUP : 1;
unsigned NormACA : 1;
unsigned TrmTsk : 1;
unsigned AERC : 1;
uint8_t AdditionalLength;
unsigned PROTECT : 1;
unsigned Res : 2;
unsigned ThreePC : 1;
unsigned TPGS : 2;
unsigned ACC : 1;
unsigned SCCS : 1;
unsigned ADDR16 : 1;
unsigned R1 : 1;
unsigned R2 : 1;
unsigned MCHNGR : 1;
unsigned MULTIP : 1;
unsigned VS : 1;
unsigned ENCSERV : 1;
unsigned BQUE : 1;
unsigned SoftReset : 1;
unsigned CmdQue : 1;
unsigned Reserved4 : 1;
unsigned Linked : 1;
unsigned Sync : 1;
unsigned WideBus16Bit : 1;
unsigned WideBus32Bit : 1;
unsigned RelAddr : 1;
uint8_t VendorID[8];
uint8_t ProductID[16];
uint8_t RevisionID[4];
} __attribute__((packed));
struct SCSI_Request_Sense_Response {
uint8_t bResponseCode;
uint8_t bSegmentNumber;
uint8_t bmSenseKey : 4;
uint8_t bmReserved : 1;
uint8_t bmILI : 1;
uint8_t bmEOM : 1;
uint8_t bmFileMark : 1;
uint8_t Information[4];
uint8_t bAdditionalLength;
uint8_t CmdSpecificInformation[4];
uint8_t bAdditionalSenseCode;
uint8_t bAdditionalSenseQualifier;
uint8_t bFieldReplaceableUnitCode;
uint8_t SenseKeySpecific[3];
} __attribute__((packed));
#endif /* UHS_SCSI_H */

33
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_UNOFFICIAL_IDs.h Normal file
View file

@ -0,0 +1,33 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#ifndef _UHS_UNOFFICIAL_IDs_h
#define _UHS_UNOFFICIAL_IDs_h
// Bogus unofficial and unregistered VIDs from cloners to be listed here.
#define UHS_VID_UNOFFICIAL_JOYTECH 0x162EU // For unofficial Joytech controllers
#endif

2995
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_USB_IDs.h Normal file
View file

@ -0,0 +1,2995 @@
/*
* USB vendor ids
* This file was generated by running python ./make-USB_IDs.py > UHS_USB_IDs.h
* Don't change it directly.
*
* Copyright 2014, Andrew J. Kroll for Circuits At Home, LTD. All rights reserved.
*
* Copyright 2012, Michal Labedzki for Tieto Corporation
* Other values imported from libghoto2/camlibs/ptp2/library.c, music-players.h
* Copyright (C) 2001-2005 Mariusz Woloszyn <emsi@ipartners.pl>
* Copyright (C) 2003-2013 Marcus Meissner <marcus@jet.franken.de>
* Copyright (C) 2005 Hubert Figuiere <hfiguiere@teaser.fr>
* Copyright (C) 2009 Axel Waggershauser <awagger@web.de>
* Copyright (C) 2005-2007 Richard A. Low <richard@wentnet.com>
* Copyright (C) 2005-2012 Linus Walleij <triad@df.lth.se>
* Copyright (C) 2007 Ted Bullock
* Copyright (C) 2012 Sony Mobile Communications AB
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _UHS_USB_IDs_h_
#define _UHS_USB_IDs_h_
#include "UHS_UNOFFICIAL_IDs.h"
#define UHS_VID_FRYS_ELECTRONICS 0x0001U // Fry's Electronics
#define UHS_VID_INGRAM 0x0002U // Ingram
#define UHS_VID_CLUB_MAC 0x0003U // Club Mac
#define UHS_VID_NEBRASKA_FURNITURE_MART 0x0004U // Nebraska Furniture Mart
#define UHS_VID_UNKNOWN 0x0011U // Unknown
#define UHS_VID_PLANEX 0x0053U // Planex
#define UHS_VID_DRAGONRISE 0x0079U // DragonRise Inc.
#define UHS_VID_TRUST_INTERNATIONAL_BV 0x0105U // Trust International B.V.
#define UHS_VID_IBP 0x0127U // IBP
#define UHS_VID_UNKNOWN_1 0x0145U // Unknown
#define UHS_VID_MLK 0x017cU // MLK
#define UHS_VID_TP_LINK 0x0200U // TP-Link
#define UHS_VID_CHIPSBANK_MICROELECTRONICS 0x0204U // Chipsbank Microelectronics Co., Ltd
#define UHS_VID_HANGZHOU_WORLDE 0x0218U // Hangzhou Worlde
#define UHS_VID_HUMAX 0x02adU // HUMAX Co., Ltd.
#define UHS_VID_MM300_EBOOK_READER 0x0300U // MM300 eBook Reader
#define UHS_VID_OCZ_TECHNOLOGY 0x0324U // OCZ Technology Inc
#define UHS_VID_OCZ_TECHNOLOGY_1 0x0325U // OCZ Technology Inc
#define UHS_VID_LTS 0x0386U // LTS
#define UHS_VID_SHENZHEN_SINOTE_TECH_ELECTRON 0x03d9U // Shenzhen Sinote Tech-Electron Co., Ltd
#define UHS_VID_BERND_WALTER_COMPUTER_TECHNOLOGY 0x03daU // Bernd Walter Computer Technology
#define UHS_VID_ENDPOINTS 0x03e8U // EndPoints, Inc.
#define UHS_VID_THESYS_MICROELECTRONICS 0x03e9U // Thesys Microelectronics
#define UHS_VID_DATA_BROADCASTING 0x03eaU // Data Broadcasting Corp.
#define UHS_VID_ATMEL 0x03ebU // Atmel Corp.
#define UHS_VID_IWATSU_AMERICA 0x03ecU // Iwatsu America, Inc.
#define UHS_VID_MITEL 0x03edU // Mitel Corp.
#define UHS_VID_MITSUMI 0x03eeU // Mitsumi
#define UHS_VID_HEWLETT_PACKARD 0x03f0U // Hewlett-Packard
#define UHS_VID_GENOA_TECHNOLOGY 0x03f1U // Genoa Technology
#define UHS_VID_OAK_TECHNOLOGY 0x03f2U // Oak Technology, Inc.
#define UHS_VID_ADAPTEC 0x03f3U // Adaptec, Inc.
#define UHS_VID_DIEBOLD 0x03f4U // Diebold, Inc.
#define UHS_VID_SIEMENS_ELECTROMECHANICAL 0x03f5U // Siemens Electromechanical
#define UHS_VID_EPSON_IMAGING_TECHNOLOGY_CENTER 0x03f8U // Epson Imaging Technology Center
#define UHS_VID_KEYTRONIC 0x03f9U // KeyTronic Corp.
#define UHS_VID_OPTI 0x03fbU // OPTi, Inc.
#define UHS_VID_ELITEGROUP_COMPUTER_SYSTEMS 0x03fcU // Elitegroup Computer Systems
#define UHS_VID_XILINX 0x03fdU // Xilinx, Inc.
#define UHS_VID_FARALLON_COMUNICATIONS 0x03feU // Farallon Comunications
#define UHS_VID_NATIONAL_SEMICONDUCTOR 0x0400U // National Semiconductor Corp.
#define UHS_VID_NATIONAL_REGISTRY 0x0401U // National Registry, Inc.
#define UHS_VID_ALI 0x0402U // ALi Corp.
#define UHS_VID_FUTURE_TECHNOLOGY_DEVICES_INTERNATIONAL 0x0403U // Future Technology Devices International, Ltd
#define UHS_VID_NCR 0x0404U // NCR Corp.
#define UHS_VID_SYNOPSYS 0x0405U // Synopsys, Inc.
#define UHS_VID_FUJITSU_ICL_COMPUTERS 0x0406U // Fujitsu-ICL Computers
#define UHS_VID_FUJITSU_PERSONAL_SYSTEMS 0x0407U // Fujitsu Personal Systems, Inc.
#define UHS_VID_QUANTA_COMPUTER 0x0408U // Quanta Computer, Inc.
#define UHS_VID_NEC 0x0409U // NEC Corp.
#define UHS_VID_KODAK 0x040aU // Kodak Co.
#define UHS_VID_WELTREND_SEMICONDUCTOR 0x040bU // Weltrend Semiconductor
#define UHS_VID_VTECH_COMPUTERS 0x040cU // VTech Computers, Ltd
#define UHS_VID_VIA_TECHNOLOGIES 0x040dU // VIA Technologies, Inc.
#define UHS_VID_MCCI 0x040eU // MCCI
#define UHS_VID_ECHO_SPEECH 0x040fU // Echo Speech Corp.
#define UHS_VID_BUFFALO_INC_FORMERLY_MELCO 0x0411U // BUFFALO INC. (formerly MelCo., Inc.)
#define UHS_VID_AWARD_SOFTWARE_INTERNATIONAL 0x0412U // Award Software International
#define UHS_VID_LEADTEK_RESEARCH 0x0413U // Leadtek Research, Inc.
#define UHS_VID_GIGA_BYTE_TECHNOLOGY 0x0414U // Giga-Byte Technology Co., Ltd
#define UHS_VID_WINBOND_ELECTRONICS 0x0416U // Winbond Electronics Corp.
#define UHS_VID_SYMBIOS_LOGIC 0x0417U // Symbios Logic
#define UHS_VID_AST_RESEARCH 0x0418U // AST Research
#define UHS_VID_SAMSUNG_INFO_SYSTEMS_AMERICA 0x0419U // Samsung Info. Systems America, Inc.
#define UHS_VID_PHOENIX_TECHNOLOGIES 0x041aU // Phoenix Technologies, Ltd
#define UHS_VID_DTV 0x041bU // d'TV
#define UHS_VID_S3 0x041dU // S3, Inc.
#define UHS_VID_CREATIVE_TECHNOLOGY 0x041eU // Creative Technology, Ltd
#define UHS_VID_LCS_TELEGRAPHICS 0x041fU // LCS Telegraphics
#define UHS_VID_CHIPS_AND_TECHNOLOGIES 0x0420U // Chips and Technologies
#define UHS_VID_NOKIA_MOBILE_PHONES 0x0421U // Nokia Mobile Phones
#define UHS_VID_ADI_SYSTEMS 0x0422U // ADI Systems, Inc.
#define UHS_VID_COMPUTER_ACCESS_TECHNOLOGY 0x0423U // Computer Access Technology Corp.
#define UHS_VID_STANDARD_MICROSYSTEMS 0x0424U // Standard Microsystems Corp.
#define UHS_VID_MOTOROLA_SEMICONDUCTORS_HK 0x0425U // Motorola Semiconductors HK, Ltd
#define UHS_VID_INTEGRATED_DEVICE_TECHNOLOGY 0x0426U // Integrated Device Technology, Inc.
#define UHS_VID_MOTOROLA_ELECTRONICS_TAIWAN 0x0427U // Motorola Electronics Taiwan, Ltd
#define UHS_VID_ADVANCED_GRAVIS_COMPUTER_TECH 0x0428U // Advanced Gravis Computer Tech, Ltd
#define UHS_VID_CIRRUS_LOGIC 0x0429U // Cirrus Logic
#define UHS_VID_ERICSSON_AUSTRIAN_AG 0x042aU // Ericsson Austrian, AG
#define UHS_VID_INTEL 0x042bU // Intel Corp.
#define UHS_VID_INNOVATIVE_SEMICONDUCTORS 0x042cU // Innovative Semiconductors, Inc.
#define UHS_VID_MICRONICS 0x042dU // Micronics
#define UHS_VID_ACER 0x042eU // Acer, Inc.
#define UHS_VID_MOLEX 0x042fU // Molex, Inc.
#define UHS_VID_SUN_MICROSYSTEMS 0x0430U // Sun Microsystems, Inc.
#define UHS_VID_ITAC_SYSTEMS 0x0431U // Itac Systems, Inc.
#define UHS_VID_UNISYS 0x0432U // Unisys Corp.
#define UHS_VID_ALPS_ELECTRIC 0x0433U // Alps Electric, Inc.
#define UHS_VID_SAMSUNG_INFO_SYSTEMS_AMERICA_1 0x0434U // Samsung Info. Systems America, Inc.
#define UHS_VID_HYUNDAI_ELECTRONICS_AMERICA 0x0435U // Hyundai Electronics America
#define UHS_VID_TAUGAGREINING_HF 0x0436U // Taugagreining HF
#define UHS_VID_FRAMATOME_CONNECTORS_USA 0x0437U // Framatome Connectors USA
#define UHS_VID_ADVANCED_MICRO_DEVICES 0x0438U // Advanced Micro Devices, Inc.
#define UHS_VID_VOICE_TECHNOLOGIES_GROUP 0x0439U // Voice Technologies Group
#define UHS_VID_LEXMARK_INTERNATIONAL 0x043dU // Lexmark International, Inc.
#define UHS_VID_LG_ELECTRONICS_USA 0x043eU // LG Electronics USA, Inc.
#define UHS_VID_RADISYS 0x043fU // RadiSys Corp.
#define UHS_VID_EIZO_NANAO 0x0440U // Eizo Nanao Corp.
#define UHS_VID_WINBOND_SYSTEMS_LAB 0x0441U // Winbond Systems Lab.
#define UHS_VID_ERICSSON 0x0442U // Ericsson, Inc.
#define UHS_VID_GATEWAY 0x0443U // Gateway, Inc.
#define UHS_VID_LUCENT_TECHNOLOGIES 0x0445U // Lucent Technologies, Inc.
#define UHS_VID_NMB_TECHNOLOGIES 0x0446U // NMB Technologies Corp.
#define UHS_VID_MOMENTUM_MICROSYSTEMS 0x0447U // Momentum Microsystems
#define UHS_VID_SHAMROCK_TECH 0x044aU // Shamrock Tech. Co., Ltd
#define UHS_VID_WSI 0x044bU // WSI
#define UHS_VID_CCLITRI 0x044cU // CCL/ITRI
#define UHS_VID_SIEMENS_NIXDORF_AG 0x044dU // Siemens Nixdorf AG
#define UHS_VID_ALPS_ELECTRIC_1 0x044eU // Alps Electric Co., Ltd
#define UHS_VID_THRUSTMASTER 0x044fU // ThrustMaster, Inc.
#define UHS_VID_DFI 0x0450U // DFI, Inc.
#define UHS_VID_TEXAS_INSTRUMENTS 0x0451U // Texas Instruments, Inc.
#define UHS_VID_MITSUBISHI_ELECTRONICS_AMERICA 0x0452U // Mitsubishi Electronics America, Inc.
#define UHS_VID_CMD_TECHNOLOGY 0x0453U // CMD Technology
#define UHS_VID_VOBIS_MICROCOMPUTER_AG 0x0454U // Vobis Microcomputer AG
#define UHS_VID_TELEMATICS_INTERNATIONAL 0x0455U // Telematics International, Inc.
#define UHS_VID_ANALOG_DEVICES 0x0456U // Analog Devices, Inc.
#define UHS_VID_SILICON_INTEGRATED_SYSTEMS 0x0457U // Silicon Integrated Systems Corp.
#define UHS_VID_KYE_SYSTEMS_CORP_MOUSE_SYSTEMS 0x0458U // KYE Systems Corp. (Mouse Systems)
#define UHS_VID_ADOBE_SYSTEMS 0x0459U // Adobe Systems, Inc.
#define UHS_VID_SONICBLUE 0x045aU // SONICblue, Inc.
#define UHS_VID_HITACHI 0x045bU // Hitachi, Ltd
#define UHS_VID_NORTEL_NETWORKS 0x045dU // Nortel Networks, Ltd
#define UHS_VID_MICROSOFT 0x045eU // Microsoft Corp.
#define UHS_VID_ACE_CAD_ENTERPRISE 0x0460U // Ace Cad Enterprise Co., Ltd
#define UHS_VID_PRIMAX_ELECTRONICS 0x0461U // Primax Electronics, Ltd
#define UHS_VID_MGE_UPS_SYSTEMS 0x0463U // MGE UPS Systems
#define UHS_VID_AMPTYCOELECTRONICS 0x0464U // AMP/Tycoelectronics Corp.
#define UHS_VID_ATANDT_PARADYNE 0x0467U // AT&T Paradyne
#define UHS_VID_WIESON_TECHNOLOGIES 0x0468U // Wieson Technologies Co., Ltd
#define UHS_VID_CHERRY 0x046aU // Cherry GmbH
#define UHS_VID_AMERICAN_MEGATRENDS 0x046bU // American Megatrends, Inc.
#define UHS_VID_TOSHIBA_CORP_DIGITAL_MEDIA_EQUIPMENT 0x046cU // Toshiba Corp., Digital Media Equipment
#define UHS_VID_LOGITECH 0x046dU // Logitech, Inc.
#define UHS_VID_BEHAVIOR_TECH_COMPUTER 0x046eU // Behavior Tech. Computer Corp.
#define UHS_VID_CRYSTAL_SEMICONDUCTOR 0x046fU // Crystal Semiconductor
#define UHS_VID_PHILIPS_OR_NXP 0x0471U // Philips (or NXP)
#define UHS_VID_CHICONY_ELECTRONICS 0x0472U // Chicony Electronics Co., Ltd
#define UHS_VID_SANYO_INFORMATION_BUSINESS 0x0473U // Sanyo Information Business Co., Ltd
#define UHS_VID_SANYO_ELECTRIC 0x0474U // Sanyo Electric Co., Ltd
#define UHS_VID_RELISYSTECO_INFORMATION_SYSTEM 0x0475U // Relisys/Teco Information System
#define UHS_VID_AESP 0x0476U // AESP
#define UHS_VID_SEAGATE_TECHNOLOGY 0x0477U // Seagate Technology, Inc.
#define UHS_VID_CONNECTIX 0x0478U // Connectix Corp.
#define UHS_VID_ADVANCED_PERIPHERAL_LABORATORIES 0x0479U // Advanced Peripheral Laboratories
#define UHS_VID_SEMTECH 0x047aU // Semtech Corp.
#define UHS_VID_SILITEK 0x047bU // Silitek Corp.
#define UHS_VID_DELL_COMPUTER 0x047cU // Dell Computer Corp.
#define UHS_VID_KENSINGTON 0x047dU // Kensington
#define UHS_VID_AGERE_SYSTEMS_INC_LUCENT 0x047eU // Agere Systems, Inc. (Lucent)
#define UHS_VID_PLANTRONICS 0x047fU // Plantronics, Inc.
#define UHS_VID_TOSHIBA_AMERICA 0x0480U // Toshiba America Inc
#define UHS_VID_ZENITH_DATA_SYSTEMS 0x0481U // Zenith Data Systems
#define UHS_VID_KYOCERA 0x0482U // Kyocera Corp.
#define UHS_VID_STMICROELECTRONICS 0x0483U // STMicroelectronics
#define UHS_VID_SPECIALIX 0x0484U // Specialix
#define UHS_VID_NOKIA_MONITORS 0x0485U // Nokia Monitors
#define UHS_VID_ASUS_COMPUTERS 0x0486U // ASUS Computers, Inc.
#define UHS_VID_STEWART_CONNECTOR 0x0487U // Stewart Connector
#define UHS_VID_CIRQUE 0x0488U // Cirque Corp.
#define UHS_VID_FOXCONN_HON_HAI 0x0489U // Foxconn / Hon Hai
#define UHS_VID_S_MOS_SYSTEMS 0x048aU // S-MOS Systems, Inc.
#define UHS_VID_ALPS_ELECTRIC_IRELAND 0x048cU // Alps Electric Ireland, Ltd
#define UHS_VID_INTEGRATED_TECHNOLOGY_EXPRESS 0x048dU // Integrated Technology Express, Inc.
#define UHS_VID_EICON_TECH 0x048fU // Eicon Tech.
#define UHS_VID_UNITED_MICROELECTRONICS 0x0490U // United Microelectronics Corp.
#define UHS_VID_CAPETRONIC 0x0491U // Capetronic
#define UHS_VID_SAMSUNG_SEMICONDUCTOR 0x0492U // Samsung SemiConductor, Inc.
#define UHS_VID_MAG_TECHNOLOGY 0x0493U // MAG Technology Co., Ltd
#define UHS_VID_ESS_TECHNOLOGY 0x0495U // ESS Technology, Inc.
#define UHS_VID_MICRON_ELECTRONICS 0x0496U // Micron Electronics
#define UHS_VID_SMILE_INTERNATIONAL 0x0497U // Smile International
#define UHS_VID_CAPETRONIC_KAOHSIUNG 0x0498U // Capetronic (Kaohsiung) Corp.
#define UHS_VID_YAMAHA 0x0499U // Yamaha Corp.
#define UHS_VID_GANDALF_TECHNOLOGIES 0x049aU // Gandalf Technologies, Ltd
#define UHS_VID_CURTIS_COMPUTER_PRODUCTS 0x049bU // Curtis Computer Products
#define UHS_VID_ACER_ADVANCED_LABS 0x049cU // Acer Advanced Labs, Inc.
#define UHS_VID_VLSI_TECHNOLOGY 0x049dU // VLSI Technology
#define UHS_VID_COMPAQ_COMPUTER 0x049fU // Compaq Computer Corp.
#define UHS_VID_DIGITAL_EQUIPMENT 0x04a0U // Digital Equipment Corp.
#define UHS_VID_SYSTEMSOFT 0x04a1U // SystemSoft Corp.
#define UHS_VID_FIREPOWER_SYSTEMS 0x04a2U // FirePower Systems
#define UHS_VID_TRIDENT_MICROSYSTEMS 0x04a3U // Trident Microsystems, Inc.
#define UHS_VID_HITACHI_1 0x04a4U // Hitachi, Ltd
#define UHS_VID_ACER_PERIPHERALS_INC_NOW_BENQ 0x04a5U // Acer Peripherals Inc. (now BenQ Corp.)
#define UHS_VID_NOKIA_DISPLAY_PRODUCTS 0x04a6U // Nokia Display Products
#define UHS_VID_VISIONEER 0x04a7U // Visioneer
#define UHS_VID_MULTIVIDEO_LABS 0x04a8U // Multivideo Labs, Inc.
#define UHS_VID_CANON 0x04a9U // Canon, Inc.
#define UHS_VID_DAEWOO_TELECOM 0x04aaU // DaeWoo Telecom, Ltd
#define UHS_VID_CHROMATIC_RESEARCH 0x04abU // Chromatic Research
#define UHS_VID_MICRO_AUDIOMETRICS 0x04acU // Micro Audiometrics Corp.
#define UHS_VID_DOOIN_ELECTRONICS 0x04adU // Dooin Electronics
#define UHS_VID_WINNOV_LP 0x04afU // Winnov L.P.
#define UHS_VID_NIKON 0x04b0U // Nikon Corp.
#define UHS_VID_PAN_INTERNATIONAL 0x04b1U // Pan International
#define UHS_VID_IBM 0x04b3U // IBM Corp.
#define UHS_VID_CYPRESS_SEMICONDUCTOR 0x04b4U // Cypress Semiconductor Corp.
#define UHS_VID_ROHM_LSI_SYSTEMS_USA 0x04b5U // ROHM LSI Systems USA, LLC
#define UHS_VID_HINT 0x04b6U // Hint Corp.
#define UHS_VID_COMPAL_ELECTRONICS 0x04b7U // Compal Electronics, Inc.
#define UHS_VID_SEIKO_EPSON 0x04b8U // Seiko Epson Corp.
#define UHS_VID_RAINBOW_TECHNOLOGIES 0x04b9U // Rainbow Technologies, Inc.
#define UHS_VID_TOUCAN_SYSTEMS 0x04baU // Toucan Systems, Ltd
#define UHS_VID_I_O_DATA_DEVICE 0x04bbU // I-O Data Device, Inc.
#define UHS_VID_TOSHIBA_ELECTRONICS_TAIWAN 0x04bdU // Toshiba Electronics Taiwan Corp.
#define UHS_VID_TELIA_RESEARCH 0x04beU // Telia Research AB
#define UHS_VID_TDK 0x04bfU // TDK Corp.
#define UHS_VID_US_ROBOTICS_3COM 0x04c1U // U.S. Robotics (3Com)
#define UHS_VID_METHODE_ELECTRONICS_FAR_EAST_PTE 0x04c2U // Methode Electronics Far East PTE, Ltd
#define UHS_VID_MAXI_SWITCH 0x04c3U // Maxi Switch, Inc.
#define UHS_VID_LOCKHEED_MARTIN_ENERGY_RESEARCH 0x04c4U // Lockheed Martin Energy Research
#define UHS_VID_FUJITSU 0x04c5U // Fujitsu, Ltd
#define UHS_VID_TOSHIBA_AMERICA_ELECTRONIC_COMPONENTS 0x04c6U // Toshiba America Electronic Components
#define UHS_VID_MICRO_MACRO_TECHNOLOGIES 0x04c7U // Micro Macro Technologies
#define UHS_VID_KONICA 0x04c8U // Konica Corp.
#define UHS_VID_LITE_ON_TECHNOLOGY 0x04caU // Lite-On Technology Corp.
#define UHS_VID_FUJI_PHOTO_FILM 0x04cbU // Fuji Photo Film Co., Ltd
#define UHS_VID_ST_ERICSSON 0x04ccU // ST-Ericsson
#define UHS_VID_TATUNG_CO_OF_AMERICA 0x04cdU // Tatung Co. Of America
#define UHS_VID_SCANLOGIC 0x04ceU // ScanLogic Corp.
#define UHS_VID_MYSON_CENTURY 0x04cfU // Myson Century, Inc.
#define UHS_VID_DIGI_INTERNATIONAL 0x04d0U // Digi International
#define UHS_VID_ITT_CANON 0x04d1U // ITT Canon
#define UHS_VID_ALTEC_LANSING_TECHNOLOGIES 0x04d2U // Altec Lansing Technologies
#define UHS_VID_VIDUS 0x04d3U // VidUS, Inc.
#define UHS_VID_LSI_LOGIC 0x04d4U // LSI Logic, Inc.
#define UHS_VID_FORTE_TECHNOLOGIES 0x04d5U // Forte Technologies, Inc.
#define UHS_VID_MENTOR_GRAPHICS 0x04d6U // Mentor Graphics
#define UHS_VID_OKI_SEMICONDUCTOR 0x04d7U // Oki Semiconductor
#define UHS_VID_MICROCHIP_TECHNOLOGY 0x04d8U // Microchip Technology, Inc.
#define UHS_VID_HOLTEK_SEMICONDUCTOR 0x04d9U // Holtek Semiconductor, Inc.
#define UHS_VID_PANASONIC_MATSUSHITA 0x04daU // Panasonic (Matsushita)
#define UHS_VID_HYPERTEC_PTY 0x04dbU // Hypertec Pty, Ltd
#define UHS_VID_HUAN_HSIN_HOLDINGS 0x04dcU // Huan Hsin Holdings, Ltd
#define UHS_VID_SHARP 0x04ddU // Sharp Corp.
#define UHS_VID_MINDSHARE 0x04deU // MindShare, Inc.
#define UHS_VID_INTERLINK_ELECTRONICS 0x04dfU // Interlink Electronics
#define UHS_VID_IIYAMA_NORTH_AMERICA 0x04e1U // Iiyama North America, Inc.
#define UHS_VID_EXAR 0x04e2U // Exar Corp.
#define UHS_VID_ZILOG 0x04e3U // Zilog, Inc.
#define UHS_VID_ACC_MICROELECTRONICS 0x04e4U // ACC Microelectronics
#define UHS_VID_PROMISE_TECHNOLOGY 0x04e5U // Promise Technology
#define UHS_VID_SCM_MICROSYSTEMS 0x04e6U // SCM Microsystems, Inc.
#define UHS_VID_ELO_TOUCHSYSTEMS 0x04e7U // Elo TouchSystems
#define UHS_VID_SAMSUNG_ELECTRONICS 0x04e8U // Samsung Electronics Co., Ltd
#define UHS_VID_PC_TEL 0x04e9U // PC-Tel, Inc.
#define UHS_VID_BROOKTREE 0x04eaU // Brooktree Corp.
#define UHS_VID_NORTHSTAR_SYSTEMS 0x04ebU // Northstar Systems, Inc.
#define UHS_VID_TOKYO_ELECTRON_DEVICE 0x04ecU // Tokyo Electron Device, Ltd
#define UHS_VID_ANNABOOKS 0x04edU // Annabooks
#define UHS_VID_PACIFIC_ELECTRONIC_INTERNATIONAL 0x04efU // Pacific Electronic International, Inc.
#define UHS_VID_DAEWOO_ELECTRONICS 0x04f0U // Daewoo Electronics Co., Ltd
#define UHS_VID_VICTOR_COMPANY_OF_JAPAN 0x04f1U // Victor Company of Japan, Ltd
#define UHS_VID_CHICONY_ELECTRONICS_1 0x04f2U // Chicony Electronics Co., Ltd
#define UHS_VID_ELAN_MICROELECTRONICS 0x04f3U // Elan Microelectronics Corp.
#define UHS_VID_HARTING_ELEKTRONIK 0x04f4U // Harting Elektronik, Inc.
#define UHS_VID_FUJITSU_ICL_SYSTEMS 0x04f5U // Fujitsu-ICL Systems, Inc.
#define UHS_VID_NORAND 0x04f6U // Norand Corp.
#define UHS_VID_NEWNEX_TECHNOLOGY 0x04f7U // Newnex Technology Corp.
#define UHS_VID_FUTUREPLUS_SYSTEMS 0x04f8U // FuturePlus Systems
#define UHS_VID_BROTHER_INDUSTRIES 0x04f9U // Brother Industries, Ltd
#define UHS_VID_DALLAS_SEMICONDUCTOR 0x04faU // Dallas Semiconductor
#define UHS_VID_BIOSTAR_MICROTECH_INTERNATIONAL 0x04fbU // Biostar Microtech International Corp.
#define UHS_VID_SUNPLUS_TECHNOLOGY 0x04fcU // Sunplus Technology Co., Ltd
#define UHS_VID_SOLITON_SYSTEMS_KK 0x04fdU // Soliton Systems, K.K.
#define UHS_VID_PFU 0x04feU // PFU, Ltd
#define UHS_VID_E_CMOS 0x04ffU // E-CMOS Corp.
#define UHS_VID_SIAM_UNITED_HI_TECH 0x0500U // Siam United Hi-Tech
#define UHS_VID_FUJIKURA_DDK 0x0501U // Fujikura DDK, Ltd
#define UHS_VID_ACER_1 0x0502U // Acer, Inc.
#define UHS_VID_HITACHI_AMERICA 0x0503U // Hitachi America, Ltd
#define UHS_VID_HAYES_MICROCOMPUTER_PRODUCTS 0x0504U // Hayes Microcomputer Products
#define UHS_VID_3COM 0x0506U // 3Com Corp.
#define UHS_VID_HOSIDEN 0x0507U // Hosiden Corp.
#define UHS_VID_CLARION 0x0508U // Clarion Co., Ltd
#define UHS_VID_AZTECH_SYSTEMS 0x0509U // Aztech Systems, Ltd
#define UHS_VID_CINCH_CONNECTORS 0x050aU // Cinch Connectors
#define UHS_VID_CABLE_SYSTEM_INTERNATIONAL 0x050bU // Cable System International
#define UHS_VID_INNOMEDIA 0x050cU // InnoMedia, Inc.
#define UHS_VID_BELKIN_COMPONENTS 0x050dU // Belkin Components
#define UHS_VID_NEON_TECHNOLOGY 0x050eU // Neon Technology, Inc.
#define UHS_VID_KC_TECHNOLOGY 0x050fU // KC Technology, Inc.
#define UHS_VID_SEJIN_ELECTRON 0x0510U // Sejin Electron, Inc.
#define UHS_VID_NABLE_DATABOOK_TECHNOLOGIES 0x0511U // N'Able (DataBook) Technologies, Inc.
#define UHS_VID_HUALON_MICROELECTRONICS 0x0512U // Hualon Microelectronics Corp.
#define UHS_VID_DIGITAL_X 0x0513U // digital-X, Inc.
#define UHS_VID_FCI_ELECTRONICS 0x0514U // FCI Electronics
#define UHS_VID_ACTC 0x0515U // ACTC
#define UHS_VID_LONGWELL_ELECTRONICS 0x0516U // Longwell Electronics
#define UHS_VID_BUTTERFLY_COMMUNICATIONS 0x0517U // Butterfly Communications
#define UHS_VID_EZKEY 0x0518U // EzKEY Corp.
#define UHS_VID_STAR_MICRONICS 0x0519U // Star Micronics Co., Ltd
#define UHS_VID_WYSE_TECHNOLOGY 0x051aU // WYSE Technology
#define UHS_VID_SILICON_GRAPHICS 0x051bU // Silicon Graphics
#define UHS_VID_SHUTTLE 0x051cU // Shuttle, Inc.
#define UHS_VID_AMERICAN_POWER_CONVERSION 0x051dU // American Power Conversion
#define UHS_VID_SCIENTIFIC_ATLANTA 0x051eU // Scientific Atlanta, Inc.
#define UHS_VID_IO_SYSTEMS_ELITE_ELECTRONICS 0x051fU // IO Systems (Elite Electronics), Inc.
#define UHS_VID_TAIWAN_SEMICONDUCTOR_MANUFACTURING 0x0520U // Taiwan Semiconductor Manufacturing Co.
#define UHS_VID_AIRBORN_CONNECTORS 0x0521U // Airborn Connectors
#define UHS_VID_ADVANCED_CONNECTEK 0x0522U // Advanced Connectek, Inc.
#define UHS_VID_ATEN 0x0523U // ATEN GmbH
#define UHS_VID_SOLA_ELECTRONICS 0x0524U // Sola Electronics
#define UHS_VID_NETCHIP_TECHNOLOGY 0x0525U // Netchip Technology, Inc.
#define UHS_VID_TEMIC_MHS 0x0526U // Temic MHS S.A.
#define UHS_VID_ALTRA 0x0527U // ALTRA
#define UHS_VID_ATI_TECHNOLOGIES 0x0528U // ATI Technologies, Inc.
#define UHS_VID_ALADDIN_KNOWLEDGE_SYSTEMS 0x0529U // Aladdin Knowledge Systems
#define UHS_VID_CRESCENT_HEART_SOFTWARE 0x052aU // Crescent Heart Software
#define UHS_VID_TEKOM_TECHNOLOGIES 0x052bU // Tekom Technologies, Inc.
#define UHS_VID_CANON_INFORMATION_SYSTEMS 0x052cU // Canon Information Systems, Inc.
#define UHS_VID_AVID_ELECTRONICS 0x052dU // Avid Electronics Corp.
#define UHS_VID_STANDARD_MICROSYSTEMS_1 0x052eU // Standard Microsystems Corp.
#define UHS_VID_UNICORE_SOFTWARE 0x052fU // Unicore Software, Inc.
#define UHS_VID_AMERICAN_MICROSYSTEMS 0x0530U // American Microsystems, Inc.
#define UHS_VID_WACOM_TECHNOLOGY 0x0531U // Wacom Technology Corp.
#define UHS_VID_SYSTECH 0x0532U // Systech Corp.
#define UHS_VID_ALCATEL_MOBILE_PHONES 0x0533U // Alcatel Mobile Phones
#define UHS_VID_MOTOROLA 0x0534U // Motorola, Inc.
#define UHS_VID_LIH_TZU_ELECTRIC 0x0535U // LIH TZU Electric Co., Ltd
#define UHS_VID_HAND_HELD_PRODUCTS_WELCH_ALLYN 0x0536U // Hand Held Products (Welch Allyn, Inc.)
#define UHS_VID_INVENTEC 0x0537U // Inventec Corp.
#define UHS_VID_CALDERA_INTERNATIONAL_INC_SCO 0x0538U // Caldera International, Inc. (SCO)
#define UHS_VID_SHYH_SHIUN_TERMINALS 0x0539U // Shyh Shiun Terminals Co., Ltd
#define UHS_VID_PREHKEYTEC 0x053aU // PrehKeyTec GmbH
#define UHS_VID_GLOBAL_VILLAGE_COMMUNICATION 0x053bU // Global Village Communication
#define UHS_VID_INSTITUT_OF_MICROELECTRONIC_AND_MECHATRONIC_SYSTEMS 0x053cU // Institut of Microelectronic & Mechatronic Systems
#define UHS_VID_SILICON_ARCHITECT 0x053dU // Silicon Architect
#define UHS_VID_MOBILITY_ELECTRONICS 0x053eU // Mobility Electronics
#define UHS_VID_SYNOPSYS_1 0x053fU // Synopsys, Inc.
#define UHS_VID_UNIACCESS 0x0540U // UniAccess AB
#define UHS_VID_SIRF_TECHNOLOGY 0x0541U // Sirf Technology, Inc.
#define UHS_VID_VIEWSONIC 0x0543U // ViewSonic Corp.
#define UHS_VID_CRISTIE_ELECTRONICS 0x0544U // Cristie Electronics, Ltd
#define UHS_VID_XIRLINK 0x0545U // Xirlink, Inc.
#define UHS_VID_POLAROID 0x0546U // Polaroid Corp.
#define UHS_VID_ANCHOR_CHIPS 0x0547U // Anchor Chips, Inc.
#define UHS_VID_TYAN_COMPUTER 0x0548U // Tyan Computer Corp.
#define UHS_VID_PIXERA 0x0549U // Pixera Corp.
#define UHS_VID_FUJITSU_MICROELECTRONICS 0x054aU // Fujitsu Microelectronics, Inc.
#define UHS_VID_NEW_MEDIA 0x054bU // New Media Corp.
#define UHS_VID_SONY 0x054cU // Sony Corp.
#define UHS_VID_TRY 0x054dU // Try Corp.
#define UHS_VID_PROSIDE 0x054eU // Proside Corp.
#define UHS_VID_WYSE_TECHNOLOGY_TAIWAN 0x054fU // WYSE Technology Taiwan
#define UHS_VID_FUJI_XEROX 0x0550U // Fuji Xerox Co., Ltd
#define UHS_VID_COMPUTREND_SYSTEMS 0x0551U // CompuTrend Systems, Inc.
#define UHS_VID_PHILIPS_MONITORS 0x0552U // Philips Monitors
#define UHS_VID_STMICROELECTRONICS_IMAGING_DIVISION_VLSI_VISION 0x0553U // STMicroelectronics Imaging Division (VLSI Vision)
#define UHS_VID_DICTAPHONE 0x0554U // Dictaphone Corp.
#define UHS_VID_ANAM_SANDT 0x0555U // ANAM S&T Co., Ltd
#define UHS_VID_ASAHI_KASEI_MICROSYSTEMS 0x0556U // Asahi Kasei Microsystems Co., Ltd
#define UHS_VID_ATEN_INTERNATIONAL 0x0557U // ATEN International Co., Ltd
#define UHS_VID_TRUEVISION 0x0558U // Truevision, Inc.
#define UHS_VID_CADENCE_DESIGN_SYSTEMS 0x0559U // Cadence Design Systems, Inc.
#define UHS_VID_KENWOOD_USA 0x055aU // Kenwood USA
#define UHS_VID_KNOWLEDGETEK 0x055bU // KnowledgeTek, Inc.
#define UHS_VID_PROTON_ELECTRONIC_IND 0x055cU // Proton Electronic Ind.
#define UHS_VID_SAMSUNG_ELECTRO_MECHANICS 0x055dU // Samsung Electro-Mechanics Co.
#define UHS_VID_CTX_OPTO_ELECTRONICS 0x055eU // CTX Opto-Electronics Corp.
#define UHS_VID_MUSTEK_SYSTEMS 0x055fU // Mustek Systems, Inc.
#define UHS_VID_INTERFACE 0x0560U // Interface Corp.
#define UHS_VID_OASIS_DESIGN 0x0561U // Oasis Design, Inc.
#define UHS_VID_TELEX_COMMUNICATIONS 0x0562U // Telex Communications, Inc.
#define UHS_VID_IMMERSION 0x0563U // Immersion Corp.
#define UHS_VID_KODAK_DIGITAL_PRODUCT_CENTER_JAPAN_LTD_FORMERLY_CHINON_INDUSTRIES 0x0564U // Kodak Digital Product Center, Japan Ltd. (formerly Chinon Industries Inc.)
#define UHS_VID_PERACOM_NETWORKS 0x0565U // Peracom Networks, Inc.
#define UHS_VID_MONTEREY_INTERNATIONAL 0x0566U // Monterey International Corp.
#define UHS_VID_XYRATEX_INTERNATIONAL 0x0567U // Xyratex International, Ltd
#define UHS_VID_QUARTZ_INGENIERIE 0x0568U // Quartz Ingenierie
#define UHS_VID_SEGASOFT 0x0569U // SegaSoft
#define UHS_VID_WACOM 0x056aU // Wacom Co., Ltd
#define UHS_VID_DECICON 0x056bU // Decicon, Inc.
#define UHS_VID_ETEK_LABS 0x056cU // eTEK Labs
#define UHS_VID_EIZO 0x056dU // EIZO Corp.
#define UHS_VID_ELECOM 0x056eU // Elecom Co., Ltd
#define UHS_VID_KOREA_DATA_SYSTEMS 0x056fU // Korea Data Systems Co., Ltd
#define UHS_VID_EPSON_AMERICA 0x0570U // Epson America
#define UHS_VID_INTEREX 0x0571U // Interex, Inc.
#define UHS_VID_CONEXANT_SYSTEMS_ROCKWELL 0x0572U // Conexant Systems (Rockwell), Inc.
#define UHS_VID_ZORAN_CO_PERSONAL_MEDIA_DIVISION_NOGATECH 0x0573U // Zoran Co. Personal Media Division (Nogatech)
#define UHS_VID_CITY_UNIVERSITY_OF_HONG_KONG 0x0574U // City University of Hong Kong
#define UHS_VID_PHILIPS_CREATIVE_DISPLAY_SOLUTIONS 0x0575U // Philips Creative Display Solutions
#define UHS_VID_BAFOQUALITY_COMPUTER_ACCESSORIES 0x0576U // BAFO/Quality Computer Accessories
#define UHS_VID_ELSA 0x0577U // ELSA
#define UHS_VID_INTRINSIX 0x0578U // Intrinsix Corp.
#define UHS_VID_GVC 0x0579U // GVC Corp.
#define UHS_VID_SAMSUNG_ELECTRONICS_AMERICA 0x057aU // Samsung Electronics America
#define UHS_VID_Y_E_DATA 0x057bU // Y-E Data, Inc.
#define UHS_VID_AVM 0x057cU // AVM GmbH
#define UHS_VID_SHARK_MULTIMEDIA 0x057dU // Shark Multimedia, Inc.
#define UHS_VID_NINTENDO 0x057eU // Nintendo Co., Ltd
#define UHS_VID_QUICKSHOT 0x057fU // QuickShot, Ltd
#define UHS_VID_DENRON 0x0580U // Denron, Inc.
#define UHS_VID_RACAL_DATA_GROUP 0x0581U // Racal Data Group
#define UHS_VID_ROLAND 0x0582U // Roland Corp.
#define UHS_VID_PADIX_CO_LTD_ROCKFIRE 0x0583U // Padix Co., Ltd (Rockfire)
#define UHS_VID_RATOC_SYSTEM 0x0584U // RATOC System, Inc.
#define UHS_VID_FLASHPOINT_TECHNOLOGY 0x0585U // FlashPoint Technology, Inc.
#define UHS_VID_ZYXEL_COMMUNICATIONS 0x0586U // ZyXEL Communications Corp.
#define UHS_VID_AMERICA_KOTOBUKI_ELECTRONICS_INDUSTRIES 0x0587U // America Kotobuki Electronics Industries, Inc.
#define UHS_VID_SAPIEN_DESIGN 0x0588U // Sapien Design
#define UHS_VID_VICTRON 0x0589U // Victron
#define UHS_VID_NOHAU 0x058aU // Nohau Corp.
#define UHS_VID_INFINEON_TECHNOLOGIES 0x058bU // Infineon Technologies
#define UHS_VID_IN_FOCUS_SYSTEMS 0x058cU // In Focus Systems
#define UHS_VID_MICREL_SEMICONDUCTOR 0x058dU // Micrel Semiconductor
#define UHS_VID_TRIPATH_TECHNOLOGY 0x058eU // Tripath Technology, Inc.
#define UHS_VID_ALCOR_MICRO 0x058fU // Alcor Micro Corp.
#define UHS_VID_OMRON 0x0590U // Omron Corp.
#define UHS_VID_QUESTRA_CONSULTING 0x0591U // Questra Consulting
#define UHS_VID_POWERWARE 0x0592U // Powerware Corp.
#define UHS_VID_INCITE 0x0593U // Incite
#define UHS_VID_PRINCETON_GRAPHIC_SYSTEMS 0x0594U // Princeton Graphic Systems
#define UHS_VID_ZORAN_MICROELECTRONICS 0x0595U // Zoran Microelectronics, Ltd
#define UHS_VID_MICROTOUCH_SYSTEMS 0x0596U // MicroTouch Systems, Inc.
#define UHS_VID_TRISIGNAL_COMMUNICATIONS 0x0597U // Trisignal Communications
#define UHS_VID_NIIGATA_CANOTEC 0x0598U // Niigata Canotec Co., Inc.
#define UHS_VID_BRILLIANCE_SEMICONDUCTOR 0x0599U // Brilliance Semiconductor, Inc.
#define UHS_VID_SPECTRUM_SIGNAL_PROCESSING 0x059aU // Spectrum Signal Processing, Inc.
#define UHS_VID_IOMEGA 0x059bU // Iomega Corp.
#define UHS_VID_A_TREND_TECHNOLOGY 0x059cU // A-Trend Technology Co., Ltd
#define UHS_VID_ADVANCED_INPUT_DEVICES 0x059dU // Advanced Input Devices
#define UHS_VID_INTELLIGENT_INSTRUMENTATION 0x059eU // Intelligent Instrumentation
#define UHS_VID_LACIE 0x059fU // LaCie, Ltd
#define UHS_VID_VETRONIX 0x05a0U // Vetronix Corp.
#define UHS_VID_USC 0x05a1U // USC Corp.
#define UHS_VID_FUJI_FILM_MICRODEVICES 0x05a2U // Fuji Film Microdevices Co., Ltd
#define UHS_VID_ARC_INTERNATIONAL 0x05a3U // ARC International
#define UHS_VID_ORTEK_TECHNOLOGY 0x05a4U // Ortek Technology, Inc.
#define UHS_VID_SAMPO_TECHNOLOGY 0x05a5U // Sampo Technology Corp.
#define UHS_VID_CISCO_SYSTEMS 0x05a6U // Cisco Systems, Inc.
#define UHS_VID_BOSE 0x05a7U // Bose Corp.
#define UHS_VID_SPACETEC_IMC 0x05a8U // Spacetec IMC Corp.
#define UHS_VID_OMNIVISION_TECHNOLOGIES 0x05a9U // OmniVision Technologies, Inc.
#define UHS_VID_UTILUX_SOUTH_CHINA 0x05aaU // Utilux South China, Ltd
#define UHS_VID_IN_SYSTEM_DESIGN 0x05abU // In-System Design
#define UHS_VID_APPLE 0x05acU // Apple, Inc.
#define UHS_VID_YC_CABLE_USA 0x05adU // Y.C. Cable U.S.A., Inc.
#define UHS_VID_SYNOPSYS_2 0x05aeU // Synopsys, Inc.
#define UHS_VID_JING_MOLD_ENTERPRISE 0x05afU // Jing-Mold Enterprise Co., Ltd
#define UHS_VID_FOUNTAIN_TECHNOLOGIES 0x05b0U // Fountain Technologies, Inc.
#define UHS_VID_FIRST_INTERNATIONAL_COMPUTER 0x05b1U // First International Computer, Inc.
#define UHS_VID_LG_SEMICON 0x05b4U // LG Semicon Co., Ltd
#define UHS_VID_DIALOGIC 0x05b5U // Dialogic Corp.
#define UHS_VID_PROXIMA 0x05b6U // Proxima Corp.
#define UHS_VID_MEDIANIX_SEMICONDUCTOR 0x05b7U // Medianix Semiconductor, Inc.
#define UHS_VID_AGILER 0x05b8U // Agiler, Inc.
#define UHS_VID_PHILIPS_RESEARCH_LABORATORIES 0x05b9U // Philips Research Laboratories
#define UHS_VID_DIGITALPERSONA 0x05baU // DigitalPersona, Inc.
#define UHS_VID_GREY_CELL_SYSTEMS 0x05bbU // Grey Cell Systems
#define UHS_VID_3G_GREEN_GREEN_GLOBE 0x05bcU // 3G Green Green Globe Co., Ltd
#define UHS_VID_RAFI_GMBH_AND_CO_KG 0x05bdU // RAFI GmbH & Co. KG
#define UHS_VID_TYCO_ELECTRONICS_RAYCHEM 0x05beU // Tyco Electronics (Raychem)
#define UHS_VID_S_AND_S_RESEARCH 0x05bfU // S & S Research
#define UHS_VID_KEIL_SOFTWARE 0x05c0U // Keil Software
#define UHS_VID_KAWASAKI_MICROELECTRONICS 0x05c1U // Kawasaki Microelectronics, Inc.
#define UHS_VID_MEDIA_PHONICS_SUISSE 0x05c2U // Media Phonics (Suisse) S.A.
#define UHS_VID_DIGI_INTERNATIONAL_1 0x05c5U // Digi International, Inc.
#define UHS_VID_QUALCOMM 0x05c6U // Qualcomm, Inc.
#define UHS_VID_QTRONIX 0x05c7U // Qtronix Corp.
#define UHS_VID_CHENG_UEI_PRECISION_INDUSTRY_CO_LTD_FOXLINK 0x05c8U // Cheng Uei Precision Industry Co., Ltd (Foxlink)
#define UHS_VID_SEMTECH_1 0x05c9U // Semtech Corp.
#define UHS_VID_RICOH 0x05caU // Ricoh Co., Ltd
#define UHS_VID_POWERVISION_TECHNOLOGIES 0x05cbU // PowerVision Technologies, Inc.
#define UHS_VID_ELSA_AG 0x05ccU // ELSA AG
#define UHS_VID_SILICOM 0x05cdU // Silicom, Ltd
#define UHS_VID_SCI_WORX 0x05ceU // sci-worx GmbH
#define UHS_VID_SUNG_FORN 0x05cfU // Sung Forn Co., Ltd
#define UHS_VID_GE_MEDICAL_SYSTEMS_LUNAR 0x05d0U // GE Medical Systems Lunar
#define UHS_VID_BRAINBOXES 0x05d1U // Brainboxes, Ltd
#define UHS_VID_WAVE_SYSTEMS 0x05d2U // Wave Systems Corp.
#define UHS_VID_TOHOKU_RICOH 0x05d3U // Tohoku Ricoh Co., Ltd
#define UHS_VID_SUPER_GATE_TECHNOLOGY 0x05d5U // Super Gate Technology Co., Ltd
#define UHS_VID_PHILIPS_SEMICONDUCTORS_CICT 0x05d6U // Philips Semiconductors, CICT
#define UHS_VID_THOMAS_AND_BETTS 0x05d7U // Thomas & Betts Corp.
#define UHS_VID_ULTIMA_ELECTRONICS 0x05d8U // Ultima Electronics Corp.
#define UHS_VID_AXIOHM_TRANSACTION_SOLUTIONS 0x05d9U // Axiohm Transaction Solutions
#define UHS_VID_MICROTEK_INTERNATIONAL 0x05daU // Microtek International, Inc.
#define UHS_VID_SUN_CORP_SUNTAC_UNKNOWN 0x05dbU // Sun Corp. (Suntac?)
#define UHS_VID_LEXAR_MEDIA 0x05dcU // Lexar Media, Inc.
#define UHS_VID_DELTA_ELECTRONICS 0x05ddU // Delta Electronics, Inc.
#define UHS_VID_SILICON_VISION 0x05dfU // Silicon Vision, Inc.
#define UHS_VID_SYMBOL_TECHNOLOGIES 0x05e0U // Symbol Technologies
#define UHS_VID_SYNTEK_SEMICONDUCTOR 0x05e1U // Syntek Semiconductor Co., Ltd
#define UHS_VID_ELECVISION 0x05e2U // ElecVision, Inc.
#define UHS_VID_GENESYS_LOGIC 0x05e3U // Genesys Logic, Inc.
#define UHS_VID_RED_WING 0x05e4U // Red Wing Corp.
#define UHS_VID_FUJI_ELECTRIC 0x05e5U // Fuji Electric Co., Ltd
#define UHS_VID_KEITHLEY_INSTRUMENTS 0x05e6U // Keithley Instruments
#define UHS_VID_ICC 0x05e8U // ICC, Inc.
#define UHS_VID_KAWASAKI_LSI 0x05e9U // Kawasaki LSI
#define UHS_VID_FFC 0x05ebU // FFC, Ltd
#define UHS_VID_COM21 0x05ecU // COM21, Inc.
#define UHS_VID_CYTECHINFO 0x05eeU // Cytechinfo Inc.
#define UHS_VID_AVB_INC_ANKO_UNKNOWN_ 0x05efU // AVB, Inc. [anko?]
#define UHS_VID_CANOPUS 0x05f0U // Canopus Co., Ltd
#define UHS_VID_COMPASS_COMMUNICATIONS 0x05f1U // Compass Communications
#define UHS_VID_DEXIN 0x05f2U // Dexin Corp., Ltd
#define UHS_VID_PI_ENGINEERING 0x05f3U // PI Engineering, Inc.
#define UHS_VID_UNIXTAR_TECHNOLOGY 0x05f5U // Unixtar Technology, Inc.
#define UHS_VID_AOC_INTERNATIONAL 0x05f6U // AOC International
#define UHS_VID_RFC_DISTRIBUTIONS_PTE 0x05f7U // RFC Distribution(s) PTE, Ltd
#define UHS_VID_PSC_SCANNING 0x05f9U // PSC Scanning, Inc.
#define UHS_VID_SIEMENS_TELECOMMUNICATIONS_SYSTEMS 0x05faU // Siemens Telecommunications Systems, Ltd
#define UHS_VID_HARMAN 0x05fcU // Harman
#define UHS_VID_INTERACT 0x05fdU // InterAct, Inc.
#define UHS_VID_CHIC_TECHNOLOGY 0x05feU // Chic Technology Corp.
#define UHS_VID_LECROY 0x05ffU // LeCroy Corp.
#define UHS_VID_BARCO_DISPLAY_SYSTEMS 0x0600U // Barco Display Systems
#define UHS_VID_JAZZ_HIPSTER 0x0601U // Jazz Hipster Corp.
#define UHS_VID_VISTA_IMAGING 0x0602U // Vista Imaging, Inc.
#define UHS_VID_NOVATEK_MICROELECTRONICS 0x0603U // Novatek Microelectronics Corp.
#define UHS_VID_JEAN 0x0604U // Jean Co., Ltd
#define UHS_VID_ANCHOR_CANDC 0x0605U // Anchor C&C Co., Ltd
#define UHS_VID_ROYAL_INFORMATION_ELECTRONICS 0x0606U // Royal Information Electronics Co., Ltd
#define UHS_VID_BRIDGE_INFORMATION 0x0607U // Bridge Information Co., Ltd
#define UHS_VID_GENRAD_ADS 0x0608U // Genrad Ads
#define UHS_VID_SMK_MANUFACTURING 0x0609U // SMK Manufacturing, Inc.
#define UHS_VID_WORTHINGTON_DATA_SOLUTIONS 0x060aU // Worthington Data Solutions, Inc.
#define UHS_VID_SOLID_YEAR 0x060bU // Solid Year
#define UHS_VID_EEH_DATALINK 0x060cU // EEH Datalink GmbH
#define UHS_VID_AUCTOR 0x060dU // Auctor Corp.
#define UHS_VID_TRANSMONDE_TECHNOLOGIES 0x060eU // Transmonde Technologies, Inc.
#define UHS_VID_JOINSOON_ELECTRONICS_MFG 0x060fU // Joinsoon Electronics Mfg. Co., Ltd
#define UHS_VID_COSTAR_ELECTRONICS 0x0610U // Costar Electronics, Inc.
#define UHS_VID_TOTOKU_ELECTRIC 0x0611U // Totoku Electric Co., Ltd
#define UHS_VID_TRANSACT_TECHNOLOGIES 0x0613U // TransAct Technologies, Inc.
#define UHS_VID_BIO_RAD_LABORATORIES 0x0614U // Bio-Rad Laboratories
#define UHS_VID_QUABBIN_WIRE_AND_CABLE 0x0615U // Quabbin Wire & Cable Co., Inc.
#define UHS_VID_FUTURE_TECHNO_DESIGNS_PVT 0x0616U // Future Techno Designs PVT, Ltd
#define UHS_VID_SWISS_FEDERAL_INSITUTE_OF_TECHNOLOGY 0x0617U // Swiss Federal Insitute of Technology
#define UHS_VID_MACALLY 0x0618U // MacAlly
#define UHS_VID_SEIKO_INSTRUMENTS 0x0619U // Seiko Instruments, Inc.
#define UHS_VID_VERIDICOM_INTERNATIONAL 0x061aU // Veridicom International, Inc.
#define UHS_VID_PROMPTUS_COMMUNICATIONS 0x061bU // Promptus Communications, Inc.
#define UHS_VID_ACT_LABS 0x061cU // Act Labs, Ltd
#define UHS_VID_QUATECH 0x061dU // Quatech, Inc.
#define UHS_VID_NISSEI_ELECTRIC 0x061eU // Nissei Electric Co.
#define UHS_VID_ALARIS 0x0620U // Alaris, Inc.
#define UHS_VID_ODU_STECKVERBINDUNGSSYSTEME_GMBH_AND_CO_KG 0x0621U // ODU-Steckverbindungssysteme GmbH & Co. KG
#define UHS_VID_IOTECH 0x0622U // Iotech, Inc.
#define UHS_VID_LITTELFUSE 0x0623U // Littelfuse, Inc.
#define UHS_VID_AVOCENT 0x0624U // Avocent Corp.
#define UHS_VID_TIMEDIA_TECHNOLOGY 0x0625U // TiMedia Technology Co., Ltd
#define UHS_VID_NIPPON_SYSTEMS_DEVELOPMENT 0x0626U // Nippon Systems Development Co., Ltd
#define UHS_VID_ADOMAX_TECHNOLOGY 0x0627U // Adomax Technology Co., Ltd
#define UHS_VID_TASKING_SOFTWARE 0x0628U // Tasking Software, Inc.
#define UHS_VID_ZIDA_TECHNOLOGIES 0x0629U // Zida Technologies, Ltd
#define UHS_VID_CREATIVE_LABS 0x062aU // Creative Labs
#define UHS_VID_GREATLINK_ELECTRONICS_TAIWAN 0x062bU // Greatlink Electronics Taiwan, Ltd
#define UHS_VID_INSTITUTE_FOR_INFORMATION_INDUSTRY 0x062cU // Institute for Information Industry
#define UHS_VID_TAIWAN_TAI_HAO_ENTERPRISES 0x062dU // Taiwan Tai-Hao Enterprises Co., Ltd
#define UHS_VID_MAINSUPER_ENTERPRISES 0x062eU // Mainsuper Enterprises Co., Ltd
#define UHS_VID_SIN_SHENG_TERMINAL_AND_MACHINE 0x062fU // Sin Sheng Terminal & Machine, Inc.
#define UHS_VID_JUJO_ELECTRONICS 0x0631U // JUJO Electronics Corp.
#define UHS_VID_CYRIX 0x0633U // Cyrix Corp.
#define UHS_VID_MICRON_TECHNOLOGY 0x0634U // Micron Technology, Inc.
#define UHS_VID_METHODE_ELECTRONICS 0x0635U // Methode Electronics, Inc.
#define UHS_VID_SIERRA_IMAGING 0x0636U // Sierra Imaging, Inc.
#define UHS_VID_AVISION 0x0638U // Avision, Inc.
#define UHS_VID_CHRONTEL 0x0639U // Chrontel, Inc.
#define UHS_VID_TECHWIN 0x063aU // Techwin Corp.
#define UHS_VID_TAUGAGREINING_HF_1 0x063bU // Taugagreining HF
#define UHS_VID_YAMAICHI_ELECTRONICS_CO_LTD_SAKURA 0x063cU // Yamaichi Electronics Co., Ltd (Sakura)
#define UHS_VID_FONG_KAI_INDUSTRIAL 0x063dU // Fong Kai Industrial Co., Ltd
#define UHS_VID_REALMEDIA_TECHNOLOGY 0x063eU // RealMedia Technology, Inc.
#define UHS_VID_NEW_TECHNOLOGY_CABLE 0x063fU // New Technology Cable, Ltd
#define UHS_VID_HITEX_DEVELOPMENT_TOOLS 0x0640U // Hitex Development Tools
#define UHS_VID_WOODS_INDUSTRIES 0x0641U // Woods Industries, Inc.
#define UHS_VID_VIA_MEDICAL 0x0642U // VIA Medical Corp.
#define UHS_VID_TEAC 0x0644U // TEAC Corp.
#define UHS_VID_WHO_UNKNOWN_VISION_SYSTEMS 0x0645U // Who? Vision Systems, Inc.
#define UHS_VID_UMAX 0x0646U // UMAX
#define UHS_VID_ACTON_RESEARCH 0x0647U // Acton Research Corp.
#define UHS_VID_INSIDE_OUT_NETWORKS 0x0648U // Inside Out Networks
#define UHS_VID_WELI_SCIENCE 0x0649U // Weli Science Co., Ltd
#define UHS_VID_ANALOG_DEVICES_INC_WHITE_MOUNTAIN_DSP 0x064bU // Analog Devices, Inc. (White Mountain DSP)
#define UHS_VID_JI_HAW_INDUSTRIAL 0x064cU // Ji-Haw Industrial Co., Ltd
#define UHS_VID_TRITECH_MICROELECTRONICS 0x064dU // TriTech Microelectronics, Ltd
#define UHS_VID_SUYIN 0x064eU // Suyin Corp.
#define UHS_VID_WIBU_SYSTEMS_AG 0x064fU // WIBU-Systems AG
#define UHS_VID_DYNAPRO_SYSTEMS 0x0650U // Dynapro Systems
#define UHS_VID_LIKOM_TECHNOLOGY_SDN_BHD 0x0651U // Likom Technology Sdn. Bhd.
#define UHS_VID_STARGATE_SOLUTIONS 0x0652U // Stargate Solutions, Inc.
#define UHS_VID_CNF 0x0653U // CNF, Inc.
#define UHS_VID_GRANITE_MICROSYSTEMS 0x0654U // Granite Microsystems, Inc.
#define UHS_VID_SPACE_SHUTTLE_HI_TECH 0x0655U // Space Shuttle Hi-Tech Co., Ltd
#define UHS_VID_GLORY_MARK_ELECTRONIC 0x0656U // Glory Mark Electronic, Ltd
#define UHS_VID_TEKCON_ELECTRONICS 0x0657U // Tekcon Electronics Corp.
#define UHS_VID_SIGMA_DESIGNS 0x0658U // Sigma Designs, Inc.
#define UHS_VID_AETHRA 0x0659U // Aethra
#define UHS_VID_OPTOELECTRONICS 0x065aU // Optoelectronics Co., Ltd
#define UHS_VID_TRACEWELL_SYSTEMS 0x065bU // Tracewell Systems
#define UHS_VID_SILICON_GRAPHICS_1 0x065eU // Silicon Graphics
#define UHS_VID_GOOD_WAY_TECHNOLOGY_CO_LTD_AND_GWC_TECHNOLOGY 0x065fU // Good Way Technology Co., Ltd & GWC technology Inc.
#define UHS_VID_TSAY_E_BVI_INTERNATIONAL 0x0660U // TSAY-E (BVI) International, Inc.
#define UHS_VID_HAMAMATSU_PHOTONICS_KK 0x0661U // Hamamatsu Photonics K.K.
#define UHS_VID_KANSAI_ELECTRIC 0x0662U // Kansai Electric Co., Ltd
#define UHS_VID_TOPMAX_ELECTRONIC 0x0663U // Topmax Electronic Co., Ltd
#define UHS_VID_ETANDT_TECHNOLOGY 0x0664U // ET&T Technology Co., Ltd.
#define UHS_VID_CYPRESS_SEMICONDUCTOR_1 0x0665U // Cypress Semiconductor
#define UHS_VID_AIWA 0x0667U // Aiwa Co., Ltd
#define UHS_VID_WORDWAND 0x0668U // WordWand
#define UHS_VID_OCE_PRINTING_SYSTEMS 0x0669U // Oce' Printing Systems GmbH
#define UHS_VID_TOTAL_TECHNOLOGIES 0x066aU // Total Technologies, Ltd
#define UHS_VID_LINKSYS 0x066bU // Linksys, Inc.
#define UHS_VID_ENTREGA 0x066dU // Entrega, Inc.
#define UHS_VID_ACER_SEMICONDUCTOR_AMERICA 0x066eU // Acer Semiconductor America, Inc.
#define UHS_VID_SIGMATEL 0x066fU // SigmaTel, Inc.
#define UHS_VID_SEQUEL_IMAGING 0x0670U // Sequel Imaging
#define UHS_VID_LABTEC 0x0672U // Labtec, Inc.
#define UHS_VID_HCL 0x0673U // HCL
#define UHS_VID_KEY_MOUSE_ELECTRONIC_ENTERPRISE 0x0674U // Key Mouse Electronic Enterprise Co., Ltd
#define UHS_VID_DRAYTEK 0x0675U // DrayTek Corp.
#define UHS_VID_TELES_AG 0x0676U // Teles AG
#define UHS_VID_AIWA_1 0x0677U // Aiwa Co., Ltd
#define UHS_VID_ACARD_TECHNOLOGY 0x0678U // ACard Technology Corp.
#define UHS_VID_PROLIFIC_TECHNOLOGY 0x067bU // Prolific Technology, Inc.
#define UHS_VID_EFFICIENT_NETWORKS 0x067cU // Efficient Networks, Inc.
#define UHS_VID_HOHNER 0x067dU // Hohner Corp.
#define UHS_VID_INTERMEC_TECHNOLOGIES 0x067eU // Intermec Technologies Corp.
#define UHS_VID_VIRATA 0x067fU // Virata, Ltd
#define UHS_VID_REALTEK_SEMICONDUCTOR_CORP_CPP_DIV_AVANCE_LOGIC 0x0680U // Realtek Semiconductor Corp., CPP Div. (Avance Logic)
#define UHS_VID_SIEMENS_INFORMATION_AND_COMMUNICATION_PRODUCTS 0x0681U // Siemens Information and Communication Products
#define UHS_VID_VICTOR_COMPANY_OF_JAPAN_1 0x0682U // Victor Company of Japan, Ltd
#define UHS_VID_ACTIONTEC_ELECTRONICS 0x0684U // Actiontec Electronics, Inc.
#define UHS_VID_ZD_INCORPORATED 0x0685U // ZD Incorporated
#define UHS_VID_MINOLTA 0x0686U // Minolta Co., Ltd
#define UHS_VID_PERTECH 0x068aU // Pertech, Inc.
#define UHS_VID_POTRANS_INTERNATIONAL 0x068bU // Potrans International, Inc.
#define UHS_VID_CH_PRODUCTS 0x068eU // CH Products, Inc.
#define UHS_VID_GOLDEN_BRIDGE_ELECTECH 0x0690U // Golden Bridge Electech, Inc.
#define UHS_VID_HAGIWARA_SYS_COM 0x0693U // Hagiwara Sys-Com Co., Ltd
#define UHS_VID_LEGO_GROUP 0x0694U // Lego Group
#define UHS_VID_CHUNTEX_CTX 0x0698U // Chuntex (CTX)
#define UHS_VID_TEKTRONIX 0x0699U // Tektronix, Inc.
#define UHS_VID_ASKEY_COMPUTER 0x069aU // Askey Computer Corp.
#define UHS_VID_THOMSON 0x069bU // Thomson, Inc.
#define UHS_VID_HUGHES_NETWORK_SYSTEMS_HNS 0x069dU // Hughes Network Systems (HNS)
#define UHS_VID_WELCAT 0x069eU // Welcat Inc.
#define UHS_VID_ALLIED_DATA_TECHNOLOGIES_BV 0x069fU // Allied Data Technologies BV
#define UHS_VID_TOPRO_TECHNOLOGY 0x06a2U // Topro Technology, Inc.
#define UHS_VID_SAITEK_PLC 0x06a3U // Saitek PLC
#define UHS_VID_XIAMEN_DOOWELL_ELECTRON 0x06a4U // Xiamen Doowell Electron Co., Ltd
#define UHS_VID_DIVIO 0x06a5U // Divio
#define UHS_VID_MICROSTORE 0x06a7U // MicroStore, Inc.
#define UHS_VID_TOPAZ_SYSTEMS 0x06a8U // Topaz Systems, Inc.
#define UHS_VID_WESTELL 0x06a9U // Westell
#define UHS_VID_SYSGRATION 0x06aaU // Sysgration, Ltd
#define UHS_VID_FUJITSU_LABORATORIES_OF_AMERICA 0x06acU // Fujitsu Laboratories of America, Inc.
#define UHS_VID_GREATLAND_ELECTRONICS_TAIWAN 0x06adU // Greatland Electronics Taiwan, Ltd
#define UHS_VID_PROFESSIONAL_MULTIMEDIA_TESTING_CENTRE 0x06aeU // Professional Multimedia Testing Centre
#define UHS_VID_HARTING_INC_OF_NORTH_AMERICA 0x06afU // Harting, Inc. of North America
#define UHS_VID_PIXELA 0x06b8U // Pixela Corp.
#define UHS_VID_ALCATEL_TELECOM 0x06b9U // Alcatel Telecom
#define UHS_VID_SMOOTH_CORD_AND_CONNECTOR 0x06baU // Smooth Cord & Connector Co., Ltd
#define UHS_VID_EDA 0x06bbU // EDA, Inc.
#define UHS_VID_OKI_DATA 0x06bcU // Oki Data Corp.
#define UHS_VID_AGFA_GEVAERT_NV 0x06bdU // AGFA-Gevaert NV
#define UHS_VID_AME_OPTIMEDIA_TECHNOLOGY 0x06beU // AME Optimedia Technology Co., Ltd
#define UHS_VID_LEOCO 0x06bfU // Leoco Corp.
#define UHS_VID_PHIDGETS_INC_FORMERLY_GLAB 0x06c2U // Phidgets Inc. (formerly GLAB)
#define UHS_VID_BIZLINK_INTERNATIONAL 0x06c4U // Bizlink International Corp.
#define UHS_VID_HAGENUK 0x06c5U // Hagenuk, GmbH
#define UHS_VID_INFOWAVE_SOFTWARE 0x06c6U // Infowave Software, Inc.
#define UHS_VID_SIIG 0x06c8U // SIIG, Inc.
#define UHS_VID_TAXAN_EUROPE 0x06c9U // Taxan (Europe), Ltd
#define UHS_VID_NEWER_TECHNOLOGY 0x06caU // Newer Technology, Inc.
#define UHS_VID_SYNAPTICS 0x06cbU // Synaptics, Inc.
#define UHS_VID_TERAYON_COMMUNICATION_SYSTEMS 0x06ccU // Terayon Communication Systems
#define UHS_VID_KEYSPAN 0x06cdU // Keyspan
#define UHS_VID_CONTEC 0x06ceU // Contec
#define UHS_VID_SPHERONVR_AG 0x06cfU // SpheronVR AG
#define UHS_VID_LAPLINK 0x06d0U // LapLink, Inc.
#define UHS_VID_DAEWOO_ELECTRONICS_1 0x06d1U // Daewoo Electronics Co., Ltd
#define UHS_VID_MITSUBISHI_ELECTRIC 0x06d3U // Mitsubishi Electric Corp.
#define UHS_VID_CISCO_SYSTEMS_1 0x06d4U // Cisco Systems
#define UHS_VID_TOSHIBA 0x06d5U // Toshiba
#define UHS_VID_AASHIMA_TECHNOLOGY_BV 0x06d6U // Aashima Technology B.V.
#define UHS_VID_NETWORK_COMPUTING_DEVICES_NCD 0x06d7U // Network Computing Devices (NCD)
#define UHS_VID_TECHNICAL_MARKETING_RESEARCH 0x06d8U // Technical Marketing Research, Inc.
#define UHS_VID_PHOENIXTEC_POWER 0x06daU // Phoenixtec Power Co., Ltd
#define UHS_VID_PARADYNE 0x06dbU // Paradyne
#define UHS_VID_FOXLINK_IMAGE_TECHNOLOGY 0x06dcU // Foxlink Image Technology Co., Ltd
#define UHS_VID_HEISEI_ELECTRONICS 0x06deU // Heisei Electronics Co., Ltd
#define UHS_VID_MULTI_TECH_SYSTEMS 0x06e0U // Multi-Tech Systems, Inc.
#define UHS_VID_ADS_TECHNOLOGIES 0x06e1U // ADS Technologies, Inc.
#define UHS_VID_ALCATEL_MICROELECTRONICS 0x06e4U // Alcatel Microelectronics
#define UHS_VID_TIGER_JET_NETWORK 0x06e6U // Tiger Jet Network, Inc.
#define UHS_VID_SIRIUS_TECHNOLOGIES 0x06eaU // Sirius Technologies
#define UHS_VID_PC_EXPERT_TECH 0x06ebU // PC Expert Tech. Co., Ltd
#define UHS_VID_IAC_GEOMETRISCHE_INGENIEURS_BV 0x06efU // I.A.C. Geometrische Ingenieurs B.V.
#define UHS_VID_TNC_INDUSTRIAL 0x06f0U // T.N.C Industrial Co., Ltd
#define UHS_VID_OPCODE_SYSTEMS 0x06f1U // Opcode Systems, Inc.
#define UHS_VID_EMINE_TECHNOLOGY 0x06f2U // Emine Technology Co.
#define UHS_VID_WINTREND_TECHNOLOGY 0x06f6U // Wintrend Technology Co., Ltd
#define UHS_VID_WAILLY_TECHNOLOGY 0x06f7U // Wailly Technology Ltd
#define UHS_VID_GUILLEMOT 0x06f8U // Guillemot Corp.
#define UHS_VID_ASYST_ELECTRONIC_DOO 0x06f9U // ASYST electronic d.o.o.
#define UHS_VID_HSD_SRL 0x06faU // HSD S.r.L
#define UHS_VID_MOTOROLA_SEMICONDUCTOR_PRODUCTS_SECTOR 0x06fcU // Motorola Semiconductor Products Sector
#define UHS_VID_BOSTON_ACOUSTICS 0x06fdU // Boston Acoustics
#define UHS_VID_GALLANT_COMPUTER 0x06feU // Gallant Computer, Inc.
#define UHS_VID_SUPERCOMAL_WIRE_AND_CABLE_SDN_BHD 0x0701U // Supercomal Wire & Cable SDN. BHD.
#define UHS_VID_BVTECH_INDUSTRY 0x0703U // Bvtech Industry, Inc.
#define UHS_VID_NKK 0x0705U // NKK Corp.
#define UHS_VID_ARIEL 0x0706U // Ariel Corp.
#define UHS_VID_STANDARD_MICROSYSTEMS_2 0x0707U // Standard Microsystems Corp.
#define UHS_VID_PUTERCOM 0x0708U // Putercom Co., Ltd
#define UHS_VID_SILICON_SYSTEMS_LTD_SSL 0x0709U // Silicon Systems, Ltd (SSL)
#define UHS_VID_OKI_ELECTRIC_INDUSTRY 0x070aU // Oki Electric Industry Co., Ltd
#define UHS_VID_COMOSS_ELECTRONIC 0x070dU // Comoss Electronic Co., Ltd
#define UHS_VID_EXCEL_CELL_ELECTRONIC 0x070eU // Excel Cell Electronic Co., Ltd
#define UHS_VID_CONNECT_TECH 0x0710U // Connect Tech, Inc.
#define UHS_VID_MAGIC_CONTROL_TECHNOLOGY 0x0711U // Magic Control Technology Corp.
#define UHS_VID_INTERVAL_RESEARCH 0x0713U // Interval Research Corp.
#define UHS_VID_NEWMOTION 0x0714U // NewMotion, Inc.
#define UHS_VID_ZNK 0x0717U // ZNK Corp.
#define UHS_VID_IMATION 0x0718U // Imation Corp.
#define UHS_VID_TREMON_ENTERPRISES 0x0719U // Tremon Enterprises Co., Ltd
#define UHS_VID_DOMAIN_TECHNOLOGIES 0x071bU // Domain Technologies, Inc.
#define UHS_VID_XIONICS_DOCUMENT_TECHNOLOGIES 0x071cU // Xionics Document Technologies, Inc.
#define UHS_VID_EICON_NETWORKS 0x071dU // Eicon Networks Corp.
#define UHS_VID_ARISTON_TECHNOLOGIES 0x071eU // Ariston Technologies
#define UHS_VID_CENTILLIUM_COMMUNICATIONS 0x0723U // Centillium Communications Corp.
#define UHS_VID_VANGUARD_INTERNATIONAL_SEMICONDUCTOR_AMERICA 0x0726U // Vanguard International Semiconductor-America
#define UHS_VID_AMITM 0x0729U // Amitm
#define UHS_VID_SUNIX 0x072eU // Sunix Co., Ltd
#define UHS_VID_ADVANCED_CARD_SYSTEMS 0x072fU // Advanced Card Systems, Ltd
#define UHS_VID_SUSTEEN 0x0731U // Susteen, Inc.
#define UHS_VID_GOLDFULL_ELECTRONICS_AND_TELECOMMUNICATIONS 0x0732U // Goldfull Electronics & Telecommunications Corp.
#define UHS_VID_VIEWQUEST_TECHNOLOGIES 0x0733U // ViewQuest Technologies, Inc.
#define UHS_VID_LASAT_COMMUNICATIONS_AS 0x0734U // Lasat Communications A/S
#define UHS_VID_ASUSCOM_NETWORK 0x0735U // Asuscom Network
#define UHS_VID_LOROM_INDUSTRIAL 0x0736U // Lorom Industrial Co., Ltd
#define UHS_VID_MAD_CATZ 0x0738U // Mad Catz, Inc.
#define UHS_VID_CHAPLET_SYSTEMS 0x073aU // Chaplet Systems, Inc.
#define UHS_VID_SUNCOM_TECHNOLOGIES 0x073bU // Suncom Technologies
#define UHS_VID_INDUSTRIAL_ELECTRONIC_ENGINEERS 0x073cU // Industrial Electronic Engineers, Inc.
#define UHS_VID_EUTRON_SPA 0x073dU // Eutron S.p.a.
#define UHS_VID_NEC_1 0x073eU // NEC, Inc.
#define UHS_VID_STOLLMANN 0x0742U // Stollmann
#define UHS_VID_SYNTECH_INFORMATION 0x0745U // Syntech Information Co., Ltd
#define UHS_VID_ONKYO 0x0746U // Onkyo Corp.
#define UHS_VID_LABWAY 0x0747U // Labway Corp.
#define UHS_VID_STRONG_MAN_ENTERPRISE 0x0748U // Strong Man Enterprise Co., Ltd
#define UHS_VID_EVER_ELECTRONICS 0x0749U // EVer Electronics Corp.
#define UHS_VID_MING_FORTUNE_INDUSTRY 0x074aU // Ming Fortune Industry Co., Ltd
#define UHS_VID_POLESTAR_TECH 0x074bU // Polestar Tech. Corp.
#define UHS_VID_C_C_C_GROUP_PLC 0x074cU // C-C-C Group PLC
#define UHS_VID_MICRONAS 0x074dU // Micronas GmbH
#define UHS_VID_DIGITAL_STREAM 0x074eU // Digital Stream Corp.
#define UHS_VID_AUREAL_SEMICONDUCTOR 0x0755U // Aureal Semiconductor
#define UHS_VID_NETWORK_TECHNOLOGIES 0x0757U // Network Technologies, Inc.
#define UHS_VID_SOPHISTICATED_CIRCUITS 0x075bU // Sophisticated Circuits, Inc.
#define UHS_VID_MIDIMAN 0x0763U // Midiman
#define UHS_VID_CYBER_POWER_SYSTEM 0x0764U // Cyber Power System, Inc.
#define UHS_VID_X_RITE 0x0765U // X-Rite, Inc.
#define UHS_VID_JESS_LINK_PRODUCTS 0x0766U // Jess-Link Products Co., Ltd
#define UHS_VID_TOKHEIM 0x0767U // Tokheim Corp.
#define UHS_VID_CAMTEL_TECHNOLOGY 0x0768U // Camtel Technology Corp.
#define UHS_VID_SURECOM_TECHNOLOGY 0x0769U // Surecom Technology Corp.
#define UHS_VID_SMART_TECHNOLOGY_ENABLERS 0x076aU // Smart Technology Enablers, Inc.
#define UHS_VID_OMNIKEY_AG 0x076bU // OmniKey AG
#define UHS_VID_PARTNER_TECH 0x076cU // Partner Tech
#define UHS_VID_DENSO 0x076dU // Denso Corp.
#define UHS_VID_KUAN_TECH_ENTERPRISE 0x076eU // Kuan Tech Enterprise Co., Ltd
#define UHS_VID_JHEN_VEI_ELECTRONIC 0x076fU // Jhen Vei Electronic Co., Ltd
#define UHS_VID_WELCH_ALLYN_INC__MEDICAL_DIVISION 0x0770U // Welch Allyn, Inc - Medical Division
#define UHS_VID_OBSERVATOR_INSTRUMENTS_BV 0x0771U // Observator Instruments BV
#define UHS_VID_YOUR_DATA_OUR_CARE 0x0772U // Your data Our Care
#define UHS_VID_AMTRAN_TECHNOLOGY 0x0774U // AmTRAN Technology Co., Ltd
#define UHS_VID_LONGSHINE_ELECTRONICS 0x0775U // Longshine Electronics Corp.
#define UHS_VID_INALWAYS 0x0776U // Inalways Corp.
#define UHS_VID_COMDA_ENTERPRISE 0x0777U // Comda Enterprise Corp.
#define UHS_VID_VOLEX 0x0778U // Volex, Inc.
#define UHS_VID_FAIRCHILD_SEMICONDUCTOR 0x0779U // Fairchild Semiconductor
#define UHS_VID_SANKYO_SEIKI_MFG 0x077aU // Sankyo Seiki Mfg. Co., Ltd
#define UHS_VID_LINKSYS_1 0x077bU // Linksys
#define UHS_VID_FORWARD_ELECTRONICS 0x077cU // Forward Electronics Co., Ltd
#define UHS_VID_GRIFFIN_TECHNOLOGY 0x077dU // Griffin Technology
#define UHS_VID_WELL_EXCELLENT_AND_MOST 0x077fU // Well Excellent & Most Corp.
#define UHS_VID_SAGEM_MONETEL 0x0780U // Sagem Monetel GmbH
#define UHS_VID_SANDISK 0x0781U // SanDisk Corp.
#define UHS_VID_TRACKERBALL 0x0782U // Trackerball
#define UHS_VID_C3PO 0x0783U // C3PO
#define UHS_VID_VIVITAR 0x0784U // Vivitar, Inc.
#define UHS_VID_NTT_ME 0x0785U // NTT-ME
#define UHS_VID_LOGITEC 0x0789U // Logitec Corp.
#define UHS_VID_HAPP_CONTROLS 0x078bU // Happ Controls, Inc.
#define UHS_VID_GTCOCALCOMP 0x078cU // GTCO/CalComp
#define UHS_VID_BRINCOM 0x078eU // Brincom, Inc.
#define UHS_VID_PRO_IMAGE_MANUFACTURING 0x0790U // Pro-Image Manufacturing Co., Ltd
#define UHS_VID_COPARTNER_WIRE_AND_CABLE_MFG 0x0791U // Copartner Wire and Cable Mfg. Corp.
#define UHS_VID_AXIS_COMMUNICATIONS 0x0792U // Axis Communications AB
#define UHS_VID_WHA_YU_INDUSTRIAL 0x0793U // Wha Yu Industrial Co., Ltd
#define UHS_VID_ABL_ELECTRONICS 0x0794U // ABL Electronics Corp.
#define UHS_VID_REALCHIP 0x0795U // RealChip, Inc.
#define UHS_VID_CERTICOM 0x0796U // Certicom Corp.
#define UHS_VID_GRANDTECH_SEMICONDUCTOR 0x0797U // Grandtech Semiconductor Corp.
#define UHS_VID_OPTELEC 0x0798U // Optelec
#define UHS_VID_ALTERA 0x0799U // Altera
#define UHS_VID_SAGEM 0x079bU // Sagem
#define UHS_VID_ALFADATA_COMPUTER 0x079dU // Alfadata Computer Corp.
#define UHS_VID_DIGICOM_SPA 0x07a1U // Digicom S.p.A.
#define UHS_VID_NATIONAL_TECHNICAL_SYSTEMS 0x07a2U // National Technical Systems
#define UHS_VID_ONNTO 0x07a3U // Onnto Corp.
#define UHS_VID_BE 0x07a4U // Be, Inc.
#define UHS_VID_ADMTEK 0x07a6U // ADMtek, Inc.
#define UHS_VID_COREGA_KK 0x07aaU // Corega K.K.
#define UHS_VID_FREECOM_TECHNOLOGIES 0x07abU // Freecom Technologies
#define UHS_VID_MICROTECH 0x07afU // Microtech
#define UHS_VID_TRUST_TECHNOLOGIES 0x07b0U // Trust Technologies
#define UHS_VID_IMP 0x07b1U // IMP, Inc.
#define UHS_VID_MOTOROLA_BCS 0x07b2U // Motorola BCS, Inc.
#define UHS_VID_PLUSTEK 0x07b3U // Plustek, Inc.
#define UHS_VID_OLYMPUS_OPTICAL 0x07b4U // Olympus Optical Co., Ltd
#define UHS_VID_MEGA_WORLD_INTERNATIONAL 0x07b5U // Mega World International, Ltd
#define UHS_VID_MARUBUN 0x07b6U // Marubun Corp.
#define UHS_VID_TIME_INTERCONNECT 0x07b7U // TIME Interconnect, Ltd
#define UHS_VID_ABOCOM_SYSTEMS 0x07b8U // AboCom Systems Inc
#define UHS_VID_CANON_COMPUTER_SYSTEMS 0x07bcU // Canon Computer Systems, Inc.
#define UHS_VID_WEBGEAR 0x07bdU // Webgear, Inc.
#define UHS_VID_VERIDICOM 0x07beU // Veridicom
#define UHS_VID_CODE_MERCENARIES_HARD_UND_SOFTWARE 0x07c0U // Code Mercenaries Hard- und Software GmbH
#define UHS_VID_KEISOKUGIKEN 0x07c1U // Keisokugiken
#define UHS_VID_DATAFAB_SYSTEMS 0x07c4U // Datafab Systems, Inc.
#define UHS_VID_APG_CASH_DRAWER 0x07c5U // APG Cash Drawer
#define UHS_VID_SHAREWAVE 0x07c6U // ShareWave, Inc.
#define UHS_VID_POWERTECH_INDUSTRIAL 0x07c7U // Powertech Industrial Co., Ltd
#define UHS_VID_BUG 0x07c8U // B.U.G., Inc.
#define UHS_VID_ALLIED_TELESYN_INTERNATIONAL 0x07c9U // Allied Telesyn International
#define UHS_VID_AVERMEDIA_TECHNOLOGIES 0x07caU // AVerMedia Technologies, Inc.
#define UHS_VID_KINGMAX_TECHNOLOGY 0x07cbU // Kingmax Technology, Inc.
#define UHS_VID_CARRY_COMPUTER_ENG 0x07ccU // Carry Computer Eng., Co., Ltd
#define UHS_VID_ELEKTOR 0x07cdU // Elektor
#define UHS_VID_CASIO_COMPUTER 0x07cfU // Casio Computer Co., Ltd
#define UHS_VID_DAZZLE 0x07d0U // Dazzle
#define UHS_VID_D_LINK_SYSTEM 0x07d1U // D-Link System
#define UHS_VID_APTIO_PRODUCTS 0x07d2U // Aptio Products, Inc.
#define UHS_VID_CYBERDATA 0x07d3U // Cyberdata Corp.
#define UHS_VID_RADIANT_SYSTEMS 0x07d5U // Radiant Systems
#define UHS_VID_GCC_TECHNOLOGIES 0x07d7U // GCC Technologies, Inc.
#define UHS_VID_ARASAN_CHIP_SYSTEMS 0x07daU // Arasan Chip Systems
#define UHS_VID_DIAMOND_MULTIMEDIA 0x07deU // Diamond Multimedia
#define UHS_VID_DAVID_ELECTRONICS 0x07dfU // David Electronics Co., Ltd
#define UHS_VID_AMBIENT_TECHNOLOGIES 0x07e1U // Ambient Technologies, Inc.
#define UHS_VID_ELMEG_GMBH_AND 0x07e2U // Elmeg GmbH & Co., Ltd
#define UHS_VID_PLANEX_COMMUNICATIONS 0x07e3U // Planex Communications, Inc.
#define UHS_VID_MOVADO_ENTERPRISE 0x07e4U // Movado Enterprise Co., Ltd
#define UHS_VID_QPS 0x07e5U // QPS, Inc.
#define UHS_VID_ALLIED_CABLE 0x07e6U // Allied Cable Corp.
#define UHS_VID_MIRVO_TOYS 0x07e7U // Mirvo Toys, Inc.
#define UHS_VID_LABSYSTEMS 0x07e8U // Labsystems
#define UHS_VID_IWATSU_ELECTRIC 0x07eaU // Iwatsu Electric Co., Ltd
#define UHS_VID_DOUBLE_H_TECHNOLOGY 0x07ebU // Double-H Technology Co., Ltd
#define UHS_VID_TAIYO_ELECTRIC_WIRE_AND_CABLE 0x07ecU // Taiyo Electric Wire & Cable Co., Ltd
#define UHS_VID_TOREX_RETAIL_FORMERLY_LOGWARE 0x07eeU // Torex Retail (formerly Logware)
#define UHS_VID_STSN 0x07efU // STSN
#define UHS_VID_MICROCOMPUTER_APPLICATIONS 0x07f2U // Microcomputer Applications, Inc.
#define UHS_VID_CIRCUIT_ASSEMBLY 0x07f6U // Circuit Assembly Corp.
#define UHS_VID_CENTURY 0x07f7U // Century Corp.
#define UHS_VID_DOTOP_TECHNOLOGY 0x07f9U // Dotop Technology, Inc.
#define UHS_VID_DRAYTEK_1 0x07faU // DrayTek Corp.
#define UHS_VID_MARK_OF_THE_UNICORN 0x07fdU // Mark of the Unicorn
#define UHS_VID_UNKNOWN_2 0x07ffU // Unknown
#define UHS_VID_MAGTEK 0x0801U // MagTek
#define UHS_VID_MAKO_TECHNOLOGIES 0x0802U // Mako Technologies, LLC
#define UHS_VID_ZOOM_TELEPHONICS 0x0803U // Zoom Telephonics, Inc.
#define UHS_VID_GENICOM_TECHNOLOGY 0x0809U // Genicom Technology, Inc.
#define UHS_VID_EVERMUCH_TECHNOLOGY 0x080aU // Evermuch Technology Co., Ltd
#define UHS_VID_CROSS_MATCH_TECHNOLOGIES 0x080bU // Cross Match Technologies
#define UHS_VID_DATALOGIC_SPA 0x080cU // Datalogic S.p.A.
#define UHS_VID_TECO_IMAGE_SYSTEMS 0x080dU // Teco Image Systems Co., Ltd
#define UHS_VID_PERSONAL_COMMUNICATION_SYSTEMS 0x0810U // Personal Communication Systems, Inc.
#define UHS_VID_MATTEL 0x0813U // Mattel, Inc.
#define UHS_VID_ELICENSER 0x0819U // eLicenser
#define UHS_VID_MG_LOGIC 0x081aU // MG Logic
#define UHS_VID_INDIGITA 0x081bU // Indigita Corp.
#define UHS_VID_MIPSYS 0x081cU // Mipsys
#define UHS_VID_ALPHASMART 0x081eU // AlphaSmart, Inc.
#define UHS_VID_REUDO 0x0822U // Reudo Corp.
#define UHS_VID_GC_PROTRONICS 0x0825U // GC Protronics
#define UHS_VID_DATA_TRANSIT 0x0826U // Data Transit
#define UHS_VID_BROADLOGIC 0x0827U // BroadLogic, Inc.
#define UHS_VID_SATO 0x0828U // Sato Corp.
#define UHS_VID_DIRECTV_BROADBAND_INC_TELOCITY 0x0829U // DirecTV Broadband, Inc. (Telocity)
#define UHS_VID_HANDSPRING 0x082dU // Handspring
#define UHS_VID_PALM 0x0830U // Palm, Inc.
#define UHS_VID_KOUWELL_ELECTRONICS 0x0832U // Kouwell Electronics Corp.
#define UHS_VID_SOURCENEXT 0x0833U // Sourcenext Corp.
#define UHS_VID_ACTION_STAR_ENTERPRISE 0x0835U // Action Star Enterprise Co., Ltd
#define UHS_VID_TREKSTOR 0x0836U // TrekStor
#define UHS_VID_SAMSUNG_TECHWIN 0x0839U // Samsung Techwin Co., Ltd
#define UHS_VID_ACCTON_TECHNOLOGY 0x083aU // Accton Technology Corp.
#define UHS_VID_GLOBAL_VILLAGE 0x083fU // Global Village
#define UHS_VID_ARGOSY_RESEARCH 0x0840U // Argosy Research, Inc.
#define UHS_VID_RIOPORTCOM 0x0841U // Rioport.com, Inc.
#define UHS_VID_WELLAND_INDUSTRIAL 0x0844U // Welland Industrial Co., Ltd
#define UHS_VID_NETGEAR 0x0846U // NetGear, Inc.
#define UHS_VID_MINTON_OPTIC_INDUSTRY 0x084dU // Minton Optic Industry Co., Inc.
#define UHS_VID_KB_GEAR 0x084eU // KB Gear
#define UHS_VID_EMPEG 0x084fU // Empeg
#define UHS_VID_FAST_POINT_TECHNOLOGIES 0x0850U // Fast Point Technologies, Inc.
#define UHS_VID_MACRONIX_INTERNATIONAL 0x0851U // Macronix International Co., Ltd
#define UHS_VID_CSEM 0x0852U // CSEM
#define UHS_VID_TOPRE_CORPORATION 0x0853U // Topre Corporation
#define UHS_VID_ACTIVEWIRE 0x0854U // ActiveWire, Inc.
#define UHS_VID_BANDB_ELECTRONICS 0x0856U // B&B Electronics
#define UHS_VID_HITACHI_MAXELL 0x0858U // Hitachi Maxell, Ltd
#define UHS_VID_MINOLTA_SYSTEMS_LABORATORY 0x0859U // Minolta Systems Laboratory, Inc.
#define UHS_VID_XIRCOM 0x085aU // Xircom
#define UHS_VID_COLORVISION 0x085cU // ColorVision, Inc.
#define UHS_VID_TELETROL_SYSTEMS 0x0862U // Teletrol Systems, Inc.
#define UHS_VID_FILANET 0x0863U // Filanet Corp.
#define UHS_VID_NETGEAR_1 0x0864U // NetGear, Inc.
#define UHS_VID_DATA_TRANSLATION 0x0867U // Data Translation, Inc.
#define UHS_VID_EMAGIC_SOFT_UND_HARDWARE 0x086aU // Emagic Soft- und Hardware GmbH
#define UHS_VID_DETEWE__DEUTSCHE_TELEPHONWERKE_AG_AND 0x086cU // DeTeWe - Deutsche Telephonwerke AG & Co.
#define UHS_VID_SYSTEM_TALKS 0x086eU // System TALKS, Inc.
#define UHS_VID_MEC_IMEX 0x086fU // MEC IMEX, Inc.
#define UHS_VID_METRICOM 0x0870U // Metricom
#define UHS_VID_SANDISK_1 0x0871U // SanDisk, Inc.
#define UHS_VID_XPEED 0x0873U // Xpeed, Inc.
#define UHS_VID_A_TEC_SUBSYSTEM 0x0874U // A-Tec Subsystem, Inc.
#define UHS_VID_COMTROL 0x0879U // Comtrol Corp.
#define UHS_VID_ADESSOKBTEK_AMERICA 0x087cU // Adesso/Kbtek America, Inc.
#define UHS_VID_JATON 0x087dU // Jaton Corp.
#define UHS_VID_FUJITSU_COMPUTER_PRODUCTS_OF_AMERICA 0x087eU // Fujitsu Computer Products of America
#define UHS_VID_QUALCORE_LOGIC 0x087fU // QualCore Logic Inc.
#define UHS_VID_APT_TECHNOLOGIES 0x0880U // APT Technologies, Inc.
#define UHS_VID_RECORDING_INDUSTRY_ASSOCIATION_OF_AMERICA_RIAA 0x0883U // Recording Industry Association of America (RIAA)
#define UHS_VID_BOCA_RESEARCH 0x0885U // Boca Research, Inc.
#define UHS_VID_XAC_AUTOMATION 0x0886U // XAC Automation Corp.
#define UHS_VID_HANNSTAR_ELECTRONICS 0x0887U // Hannstar Electronics Corp.
#define UHS_VID_TECHTOOLS 0x088aU // TechTools
#define UHS_VID_MASSWORKS 0x088bU // MassWorks, Inc.
#define UHS_VID_SWECOIN 0x088cU // Swecoin AB
#define UHS_VID_ILOK 0x088eU // iLok
#define UHS_VID_DIOGRAPHY 0x0892U // DioGraphy, Inc.
#define UHS_VID_TSI_INCORPORATED 0x0894U // TSI Incorporated
#define UHS_VID_LAUTERBACH 0x0897U // Lauterbach
#define UHS_VID_UNITED_TECHNOLOGIES_RESEARCH_CNTR 0x089cU // United Technologies Research Cntr.
#define UHS_VID_ICRON_TECHNOLOGIES 0x089dU // Icron Technologies Corp.
#define UHS_VID_NST 0x089eU // NST Co., Ltd
#define UHS_VID_PRIMEX_AEROSPACE 0x089fU // Primex Aerospace Co.
#define UHS_VID_E9 0x08a5U // e9, Inc.
#define UHS_VID_TOSHIBA_TEC 0x08a6U // Toshiba TEC
#define UHS_VID_ANDREA_ELECTRONICS 0x08a8U // Andrea Electronics
#define UHS_VID_CWAV 0x08a9U // CWAV Inc.
#define UHS_VID_MACRAIGOR_SYSTEMS 0x08acU // Macraigor Systems LLC
#define UHS_VID_MACALLY_MACE_GROUP 0x08aeU // Macally (Mace Group, Inc.)
#define UHS_VID_METROHM 0x08b0U // Metrohm
#define UHS_VID_SORENSON_VISION 0x08b4U // Sorenson Vision, Inc.
#define UHS_VID_NATSU 0x08b7U // NATSU
#define UHS_VID_J_GORDON_ELECTRONIC_DESIGN 0x08b8U // J. Gordon Electronic Design, Inc.
#define UHS_VID_RADIOSHACK_CORP_TANDY 0x08b9U // RadioShack Corp. (Tandy)
#define UHS_VID_TEXAS_INSTRUMENTS_1 0x08bbU // Texas Instruments
#define UHS_VID_CITIZEN_WATCH 0x08bdU // Citizen Watch Co., Ltd
#define UHS_VID_PRECISE_BIOMETRICS 0x08c3U // Precise Biometrics
#define UHS_VID_PROXIM 0x08c4U // Proxim, Inc.
#define UHS_VID_KEY_NICE_ENTERPRISE 0x08c7U // Key Nice Enterprise Co., Ltd
#define UHS_VID_2WIRE 0x08c8U // 2Wire, Inc.
#define UHS_VID_NIPPON_TELEGRAPH_AND_TELEPHONE 0x08c9U // Nippon Telegraph and Telephone Corp.
#define UHS_VID_AIPTEK_INTERNATIONAL 0x08caU // Aiptek International, Inc.
#define UHS_VID_JUE_HSUN_IND 0x08cdU // Jue Hsun Ind. Corp.
#define UHS_VID_LONG_WELL_ELECTRONICS 0x08ceU // Long Well Electronics Corp.
#define UHS_VID_PRODUCTIVITY_ENHANCEMENT_PRODUCTS 0x08cfU // Productivity Enhancement Products
#define UHS_VID_SMARTBRIDGES 0x08d1U // smartBridges, Inc.
#define UHS_VID_VIRTUAL_INK 0x08d3U // Virtual Ink
#define UHS_VID_FUJITSU_SIEMENS_COMPUTERS 0x08d4U // Fujitsu Siemens Computers
#define UHS_VID_IXXAT_AUTOMATION 0x08d8U // IXXAT Automation GmbH
#define UHS_VID_INCREMENT_P 0x08d9U // Increment P Corp.
#define UHS_VID_BILLIONTON_SYSTEMS 0x08ddU // Billionton Systems, Inc.
#define UHS_VID__UNKNOWN 0x08deU // ?
#define UHS_VID_SPYRUS 0x08dfU // Spyrus, Inc.
#define UHS_VID_OLITEC 0x08e3U // Olitec, Inc.
#define UHS_VID_PIONEER 0x08e4U // Pioneer Corp.
#define UHS_VID_LITRONIC 0x08e5U // Litronic
#define UHS_VID_GEMALTO_WAS_GEMPLUS 0x08e6U // Gemalto (was Gemplus)
#define UHS_VID_PAN_INTERNATIONAL_WIRE_AND_CABLE 0x08e7U // Pan-International Wire & Cable
#define UHS_VID_INTEGRATED_MEMORY_LOGIC 0x08e8U // Integrated Memory Logic
#define UHS_VID_EXTENDED_SYSTEMS 0x08e9U // Extended Systems, Inc.
#define UHS_VID_ERICSSON_INC_BLUE_RIDGE_LABS 0x08eaU // Ericsson, Inc., Blue Ridge Labs
#define UHS_VID_M_SYSTEMS_FLASH_DISK_PIONEERS 0x08ecU // M-Systems Flash Disk Pioneers
#define UHS_VID_MEDIATEK 0x08edU // MediaTek Inc.
#define UHS_VID_CCSIHESSO 0x08eeU // CCSI/Hesso
#define UHS_VID_COREX_TECHNOLOGIES 0x08f0U // Corex Technologies
#define UHS_VID_CTI_ELECTRONICS 0x08f1U // CTI Electronics Corp.
#define UHS_VID_GOTOP_INFORMATION 0x08f2U // Gotop Information Inc.
#define UHS_VID_SYSTEC 0x08f5U // SysTec Co., Ltd
#define UHS_VID_LOGIC_3_INTERNATIONAL 0x08f6U // Logic 3 International, Ltd
#define UHS_VID_VERNIER 0x08f7U // Vernier
#define UHS_VID_KEEN_TOP_INTERNATIONAL_ENTERPRISE 0x08f8U // Keen Top International Enterprise Co., Ltd
#define UHS_VID_WIPRO_TECHNOLOGIES 0x08f9U // Wipro Technologies
#define UHS_VID_CAERE 0x08faU // Caere
#define UHS_VID_SOCKET_COMMUNICATIONS 0x08fbU // Socket Communications
#define UHS_VID_SICON_CABLE_TECHNOLOGY 0x08fcU // Sicon Cable Technology Co., Ltd
#define UHS_VID_DIGIANSWER_AS 0x08fdU // Digianswer A/S
#define UHS_VID_AUTHENTEC 0x08ffU // AuthenTec, Inc.
#define UHS_VID_PINNACLE_SYSTEMS 0x0900U // Pinnacle Systems, Inc.
#define UHS_VID_VST_TECHNOLOGIES 0x0901U // VST Technologies
#define UHS_VID_FARADAY_TECHNOLOGY 0x0906U // Faraday Technology Corp.
#define UHS_VID_SIEMENS_AG 0x0908U // Siemens AG
#define UHS_VID_AUDIO_TECHNICA 0x0909U // Audio-Technica Corp.
#define UHS_VID_TRUMPION_MICROELECTRONICS 0x090aU // Trumpion Microelectronics, Inc.
#define UHS_VID_NEUROSMITH 0x090bU // Neurosmith
#define UHS_VID_SILICON_MOTION_INC__TAIWAN_FORMERLY_FEIYA_TECHNOLOGY 0x090cU // Silicon Motion, Inc. - Taiwan (formerly Feiya Technology Corp.)
#define UHS_VID_MULTIPORT_COMPUTER_VERTRIEBS 0x090dU // Multiport Computer Vertriebs GmbH
#define UHS_VID_SHINING_TECHNOLOGY 0x090eU // Shining Technology, Inc.
#define UHS_VID_FUJITSU_DEVICES 0x090fU // Fujitsu Devices, Inc.
#define UHS_VID_ALATION_SYSTEMS 0x0910U // Alation Systems, Inc.
#define UHS_VID_PHILIPS_SPEECH_PROCESSING 0x0911U // Philips Speech Processing
#define UHS_VID_VOQUETTE 0x0912U // Voquette, Inc.
#define UHS_VID_GLOBESPAN 0x0915U // GlobeSpan, Inc.
#define UHS_VID_SMARTDISK 0x0917U // SmartDisk Corp.
#define UHS_VID_TIGER_ELECTRONICS 0x0919U // Tiger Electronics
#define UHS_VID_GARMIN_INTERNATIONAL 0x091eU // Garmin International
#define UHS_VID_ECHELON 0x0920U // Echelon Co.
#define UHS_VID_GOHUBS 0x0921U // GoHubs, Inc.
#define UHS_VID_DYMO_COSTAR 0x0922U // Dymo-CoStar Corp.
#define UHS_VID_IC_MEDIA 0x0923U // IC Media Corp.
#define UHS_VID_XEROX 0x0924U // Xerox
#define UHS_VID_LAKEVIEW_RESEARCH 0x0925U // Lakeview Research
#define UHS_VID_SUMMUS 0x0927U // Summus, Ltd
#define UHS_VID_PLX_TECHNOLOGY_INC_FORMERLY_OXFORD_SEMICONDUCTOR 0x0928U // PLX Technology, Inc. (formerly Oxford Semiconductor, Ltd)
#define UHS_VID_AMERICAN_BIOMETRIC 0x0929U // American Biometric Co.
#define UHS_VID_TOSHIBA_INFORMATION_AND_INDUSTRIAL_SYS_AND_SERVICES 0x092aU // Toshiba Information & Industrial Sys. And Services
#define UHS_VID_SENA_TECHNOLOGIES 0x092bU // Sena Technologies, Inc.
#define UHS_VID_NORTHERN_EMBEDDED_SCIENCECAVNEX 0x092fU // Northern Embedded Science/CAVNEX
#define UHS_VID_TOSHIBA_1 0x0930U // Toshiba Corp.
#define UHS_VID_HARMONIC_DATA_SYSTEMS 0x0931U // Harmonic Data Systems, Ltd
#define UHS_VID_CRESCENTEC 0x0932U // Crescentec Corp.
#define UHS_VID_QUANTUM 0x0933U // Quantum Corp.
#define UHS_VID_SPIRENT_COMMUNICATIONS 0x0934U // Spirent Communications
#define UHS_VID_NUTESLA 0x0936U // NuTesla
#define UHS_VID_LUMBERG 0x0939U // Lumberg, Inc.
#define UHS_VID_PIXART_IMAGING 0x093aU // Pixart Imaging, Inc.
#define UHS_VID_PLEXTOR 0x093bU // Plextor Corp.
#define UHS_VID_INTREPID_CONTROL_SYSTEMS 0x093cU // Intrepid Control Systems, Inc.
#define UHS_VID_INNOSYNC 0x093dU // InnoSync, Inc.
#define UHS_VID_JST_MFG 0x093eU // J.S.T. Mfg. Co., Ltd
#define UHS_VID_OLYMPIA_TELECOM_VERTRIEBS 0x093fU // Olympia Telecom Vertriebs GmbH
#define UHS_VID_JAPAN_STORAGE_BATTERY 0x0940U // Japan Storage Battery Co., Ltd
#define UHS_VID_PHOTOBIT 0x0941U // Photobit Corp.
#define UHS_VID_I2GOCOM 0x0942U // i2Go.com, LLC
#define UHS_VID_HCL_TECHNOLOGIES_INDIA_PRIVATE 0x0943U // HCL Technologies India Private, Ltd
#define UHS_VID_KORG 0x0944U // KORG, Inc.
#define UHS_VID_PASCO_SCIENTIFIC 0x0945U // Pasco Scientific
#define UHS_VID_KRONAUER_MUSIC_IN_DIGITAL 0x0948U // Kronauer music in digital
#define UHS_VID_LINKUP_SYSTEMS 0x094bU // Linkup Systems Corp.
#define UHS_VID_CABLE_TELEVISION_LABORATORIES 0x094dU // Cable Television Laboratories
#define UHS_VID_YANO 0x094fU // Yano
#define UHS_VID_KINGSTON_TECHNOLOGY 0x0951U // Kingston Technology
#define UHS_VID_RPM_SYSTEMS 0x0954U // RPM Systems Corp.
#define UHS_VID_NVIDIA 0x0955U // NVidia Corp.
#define UHS_VID_BSQUARE 0x0956U // BSquare Corp.
#define UHS_VID_AGILENT_TECHNOLOGIES 0x0957U // Agilent Technologies, Inc.
#define UHS_VID_COMPULINK_RESEARCH 0x0958U // CompuLink Research, Inc.
#define UHS_VID_COLOGNE_CHIP_AG 0x0959U // Cologne Chip AG
#define UHS_VID_PORTSMITH 0x095aU // Portsmith
#define UHS_VID_MEDIALOGIC 0x095bU // Medialogic Corp.
#define UHS_VID_K_TEC_ELECTRONICS 0x095cU // K-Tec Electronics
#define UHS_VID_POLYCOM 0x095dU // Polycom, Inc.
#define UHS_VID_ACER_NEWEB 0x0967U // Acer NeWeb Corp.
#define UHS_VID_CATALYST_ENTERPRISES 0x0968U // Catalyst Enterprises, Inc.
#define UHS_VID_FEITIAN_TECHNOLOGIES 0x096eU // Feitian Technologies, Inc.
#define UHS_VID_GRETAG_MACBETH_AG 0x0971U // Gretag-Macbeth AG
#define UHS_VID_SCHLUMBERGER 0x0973U // Schlumberger
#define UHS_VID_DATAGRAPHIX_A_BUSINESS_UNIT_OF_ANACOMP 0x0974U // Datagraphix, a business unit of Anacomp
#define UHS_VID_OLE_COMMUNICATIONS 0x0975U // OL'E Communications, Inc.
#define UHS_VID_ADIRONDACK_WIRE_AND_CABLE 0x0976U // Adirondack Wire & Cable
#define UHS_VID_LIGHTSURF_TECHNOLOGIES 0x0977U // Lightsurf Technologies
#define UHS_VID_BECKHOFF 0x0978U // Beckhoff GmbH
#define UHS_VID_JEILIN_TECHNOLOGY 0x0979U // Jeilin Technology Corp., Ltd
#define UHS_VID_MINDS_AT_WORK 0x097aU // Minds At Work LLC
#define UHS_VID_KNUDSEN_ENGINEERING 0x097bU // Knudsen Engineering, Ltd
#define UHS_VID_MARUNIX 0x097cU // Marunix Co., Ltd
#define UHS_VID_ROSUN_TECHNOLOGIES 0x097dU // Rosun Technologies, Inc.
#define UHS_VID_BIOPAC_SYSTEMS 0x097eU // Biopac Systems Inc.
#define UHS_VID_BARUN_ELECTRONICS 0x097fU // Barun Electronics Co., Ltd
#define UHS_VID_OAK_TECHNOLOGY_1 0x0981U // Oak Technology, Ltd
#define UHS_VID_APRICORN 0x0984U // Apricorn
#define UHS_VID_CAB_PRODUKTTECHNIK_GMBH_AND_CO_KG 0x0985U // cab Produkttechnik GmbH & Co KG
#define UHS_VID_MATSUSHITA_ELECTRIC_WORKS 0x0986U // Matsushita Electric Works, Ltd.
#define UHS_VID_VITANA 0x098cU // Vitana Corp.
#define UHS_VID_INDESIGN 0x098dU // INDesign
#define UHS_VID_INTEGRATED_INTELLECTUAL_PROPERTY 0x098eU // Integrated Intellectual Property, Inc.
#define UHS_VID_KENWOOD_TMI 0x098fU // Kenwood TMI Corp.
#define UHS_VID_GEMSTAR_EBOOK_GROUP 0x0993U // Gemstar eBook Group, Ltd
#define UHS_VID_INTEGRATED_TELECOM_EXPRESS 0x0996U // Integrated Telecom Express, Inc.
#define UHS_VID_ZIPPY_TECHNOLOGY 0x099aU // Zippy Technology Corp.
#define UHS_VID_PAIRGAIN_TECHNOLOGIES 0x09a3U // PairGain Technologies
#define UHS_VID_CONTECH_RESEARCH 0x09a4U // Contech Research, Inc.
#define UHS_VID_VCON_TELECOMMUNICATIONS 0x09a5U // VCON Telecommunications
#define UHS_VID_POINCHIPS 0x09a6U // Poinchips
#define UHS_VID_DATA_TRANSMISSION_NETWORK 0x09a7U // Data Transmission Network Corp.
#define UHS_VID_LIN_SHIUNG_ENTERPRISE 0x09a8U // Lin Shiung Enterprise Co., Ltd
#define UHS_VID_SMART_CARD_TECHNOLOGIES 0x09a9U // Smart Card Technologies Co., Ltd
#define UHS_VID_INTERSIL 0x09aaU // Intersil Corp.
#define UHS_VID_JAPAN_CASH_MACHINE 0x09abU // Japan Cash Machine Co., Ltd.
#define UHS_VID_TRIPP_LITE 0x09aeU // Tripp Lite
#define UHS_VID_FRANKLIN_ELECTRONIC_PUBLISHERS 0x09b2U // Franklin Electronic Publishers, Inc.
#define UHS_VID_ALTIUS_SOLUTIONS 0x09b3U // Altius Solutions, Inc.
#define UHS_VID_MDS_TELEPHONE_SYSTEMS 0x09b4U // MDS Telephone Systems
#define UHS_VID_CELLTRIX_TECHNOLOGY 0x09b5U // Celltrix Technology Co., Ltd
#define UHS_VID_GRUNDIG 0x09bcU // Grundig
#define UHS_VID_MYSMARTCOM 0x09beU // MySmart.Com
#define UHS_VID_AUERSWALD_GMBH_AND_CO_KG 0x09bfU // Auerswald GmbH & Co. KG
#define UHS_VID_GENPIX_ELECTRONICS 0x09c0U // Genpix Electronics, LLC
#define UHS_VID_ARRIS_INTERACTIVE 0x09c1U // Arris Interactive LLC
#define UHS_VID_NISCA 0x09c2U // Nisca Corp.
#define UHS_VID_ACTIVCARD 0x09c3U // ActivCard, Inc.
#define UHS_VID_ACTISYS 0x09c4U // ACTiSYS Corp.
#define UHS_VID_MEMORY 0x09c5U // Memory Corp.
#define UHS_VID_BMC_MESSSYSTEME 0x09caU // BMC Messsysteme GmbH
#define UHS_VID_WORKBIT 0x09ccU // Workbit Corp.
#define UHS_VID_PSION_DACOM_HOME_NETWORKS 0x09cdU // Psion Dacom Home Networks, Ltd
#define UHS_VID_CITY_ELECTRONICS 0x09ceU // City Electronics, Ltd
#define UHS_VID_ELECTRONICS_TESTING_CENTER_TAIWAN 0x09cfU // Electronics Testing Center, Taiwan
#define UHS_VID_NEOMAGIC 0x09d1U // NeoMagic, Inc.
#define UHS_VID_VREELIN_ENGINEERING 0x09d2U // Vreelin Engineering, Inc.
#define UHS_VID_COM_ONE 0x09d3U // Com One
#define UHS_VID_NOVATEL_WIRELESS 0x09d7U // Novatel Wireless
#define UHS_VID_KRF_TECH 0x09d9U // KRF Tech, Ltd
#define UHS_VID_A4TECH 0x09daU // A4Tech Co., Ltd.
#define UHS_VID_MEASUREMENT_COMPUTING 0x09dbU // Measurement Computing Corp.
#define UHS_VID_AIMEX 0x09dcU // Aimex Corp.
#define UHS_VID_FELLOWES 0x09ddU // Fellowes, Inc.
#define UHS_VID_ADDONICS_TECHNOLOGIES 0x09dfU // Addonics Technologies Corp.
#define UHS_VID_INTELLON 0x09e1U // Intellon Corp.
#define UHS_VID_JO_DAN_INTERNATIONAL 0x09e5U // Jo-Dan International, Inc.
#define UHS_VID_SILUTIA 0x09e6U // Silutia, Inc.
#define UHS_VID_REAL_3D 0x09e7U // Real 3D, Inc.
#define UHS_VID_AKAI_PROFESSIONAL_MI 0x09e8U // AKAI Professional M.I. Corp.
#define UHS_VID_CHEN_SOURCE 0x09e9U // Chen-Source, Inc.
#define UHS_VID_IM_NETWORKS 0x09ebU // IM Networks, Inc.
#define UHS_VID_XITEL 0x09efU // Xitel
#define UHS_VID_GOFLIGHT 0x09f3U // GoFlight, Inc.
#define UHS_VID_ARESCOM 0x09f5U // AresCom
#define UHS_VID_ROCKETCHIPS 0x09f6U // RocketChips, Inc.
#define UHS_VID_EDU_SCIENCE_HK 0x09f7U // Edu-Science (H.K.), Ltd
#define UHS_VID_SOFTCONNEX_TECHNOLOGIES 0x09f8U // SoftConnex Technologies, Inc.
#define UHS_VID_BAY_ASSOCIATES 0x09f9U // Bay Associates
#define UHS_VID_MTEK_VISION 0x09faU // Mtek Vision
#define UHS_VID_ALTERA_1 0x09fbU // Altera
#define UHS_VID_GAIN_TECHNOLOGY 0x09ffU // Gain Technology Corp.
#define UHS_VID_LIQUID_AUDIO 0x0a00U // Liquid Audio
#define UHS_VID_VIA 0x0a01U // ViA, Inc.
#define UHS_VID_UNKNOWN_MANUFACTURER 0x0a05U // Unknown Manufacturer
#define UHS_VID_ONTRAK_CONTROL_SYSTEMS 0x0a07U // Ontrak Control Systems Inc.
#define UHS_VID_CYBEX_COMPUTER_PRODUCTS 0x0a0bU // Cybex Computer Products Co.
#define UHS_VID_SERVERGY 0x0a0dU // Servergy, Inc
#define UHS_VID_XENTEC 0x0a11U // Xentec, Inc.
#define UHS_VID_CAMBRIDGE_SILICON_RADIO 0x0a12U // Cambridge Silicon Radio, Ltd
#define UHS_VID_TELEBYTE 0x0a13U // Telebyte, Inc.
#define UHS_VID_SPACELABS_MEDICAL 0x0a14U // Spacelabs Medical, Inc.
#define UHS_VID_SCALAR 0x0a15U // Scalar Corp.
#define UHS_VID_TREK_TECHNOLOGY_S_PTE 0x0a16U // Trek Technology (S) PTE, Ltd
#define UHS_VID_PENTAX 0x0a17U // Pentax Corp.
#define UHS_VID_HEIDELBERGER_DRUCKMASCHINEN_AG 0x0a18U // Heidelberger Druckmaschinen AG
#define UHS_VID_HUA_GENG_TECHNOLOGIES 0x0a19U // Hua Geng Technologies, Inc.
#define UHS_VID_MEDTRONIC_PHYSIO_CONTROL 0x0a21U // Medtronic Physio Control Corp.
#define UHS_VID_CENTURY_SEMICONDUCTOR_USA 0x0a22U // Century Semiconductor USA, Inc.
#define UHS_VID_DATACARD_GROUP 0x0a27U // Datacard Group
#define UHS_VID_AK_MODUL_BUS_COMPUTER 0x0a2cU // AK-Modul-Bus Computer GmbH
#define UHS_VID_TG3_ELECTRONICS 0x0a34U // TG3 Electronics, Inc.
#define UHS_VID_RADIKAL_TECHNOLOGIES 0x0a35U // Radikal Technologies
#define UHS_VID_GILAT_SATELLITE_NETWORKS 0x0a39U // Gilat Satellite Networks, Ltd
#define UHS_VID_PENTAMEDIA 0x0a3aU // PentaMedia Co., Ltd
#define UHS_VID_NTT_DOCOMO 0x0a3cU // NTT DoCoMo, Inc.
#define UHS_VID_VARO_VISION 0x0a3dU // Varo Vision
#define UHS_VID_SWISSONIC_AG 0x0a3fU // Swissonic AG
#define UHS_VID_BOCA_SYSTEMS 0x0a43U // Boca Systems, Inc.
#define UHS_VID_DAVICOM_SEMICONDUCTOR 0x0a46U // Davicom Semiconductor, Inc.
#define UHS_VID_HIROSE_ELECTRIC 0x0a47U // Hirose Electric
#define UHS_VID_IO_INTERCONNECT 0x0a48U // I/O Interconnect
#define UHS_VID_PLOYTEC 0x0a4aU // Ploytec GmbH
#define UHS_VID_FUJITSU_MEDIA_DEVICES 0x0a4bU // Fujitsu Media Devices, Ltd
#define UHS_VID_COMPUTEX 0x0a4cU // Computex Co., Ltd
#define UHS_VID_EVOLUTION_ELECTRONICS 0x0a4dU // Evolution Electronics, Ltd
#define UHS_VID_STEINBERG_SOFT_UND_HARDWARE 0x0a4eU // Steinberg Soft-und Hardware GmbH
#define UHS_VID_LITTON_SYSTEMS 0x0a4fU // Litton Systems, Inc.
#define UHS_VID_MIMAKI_ENGINEERING 0x0a50U // Mimaki Engineering Co., Ltd
#define UHS_VID_SONY_ELECTRONICS 0x0a51U // Sony Electronics, Inc.
#define UHS_VID_JEBSEE_ELECTRONICS 0x0a52U // Jebsee Electronics Co., Ltd
#define UHS_VID_PORTABLE_PERIPHERAL 0x0a53U // Portable Peripheral Co., Ltd
#define UHS_VID_ELECTRONICS_FOR_IMAGING 0x0a5aU // Electronics For Imaging, Inc.
#define UHS_VID_EASICS_NV 0x0a5bU // EAsics NV
#define UHS_VID_BROADCOM 0x0a5cU // Broadcom Corp.
#define UHS_VID_DIATREND 0x0a5dU // Diatrend Corp.
#define UHS_VID_ZEBRA 0x0a5fU // Zebra
#define UHS_VID_MPMAN 0x0a62U // MPMan
#define UHS_VID_CLEARCUBE_TECHNOLOGY 0x0a66U // ClearCube Technology
#define UHS_VID_MEDELI_ELECTRONICS 0x0a67U // Medeli Electronics Co., Ltd
#define UHS_VID_COMAIDE 0x0a68U // Comaide Corp.
#define UHS_VID_CHROMA_ATE 0x0a69U // Chroma ate, Inc.
#define UHS_VID_GREEN_HOUSE 0x0a6bU // Green House Co., Ltd
#define UHS_VID_INTEGRATED_CIRCUIT_SYSTEMS 0x0a6cU // Integrated Circuit Systems, Inc.
#define UHS_VID_UPS_MANUFACTURING 0x0a6dU // UPS Manufacturing
#define UHS_VID_BENWIN 0x0a6eU // Benwin
#define UHS_VID_CORE_TECHNOLOGY 0x0a6fU // Core Technology, Inc.
#define UHS_VID_INTERNATIONAL_GAME_TECHNOLOGY 0x0a70U // International Game Technology
#define UHS_VID_VIPCOLOR_TECHNOLOGIES_USA 0x0a71U // VIPColor Technologies USA, Inc.
#define UHS_VID_SANWA_DENSHI 0x0a72U // Sanwa Denshi
#define UHS_VID_MACKIE_DESIGNS 0x0a73U // Mackie Designs
#define UHS_VID_NSTL 0x0a7dU // NSTL, Inc.
#define UHS_VID_OCTAGON_SYSTEMS 0x0a7eU // Octagon Systems Corp.
#define UHS_VID_REXON_TECHNOLOGY 0x0a80U // Rexon Technology Corp., Ltd
#define UHS_VID_CHESEN_ELECTRONICS 0x0a81U // Chesen Electronics Corp.
#define UHS_VID_SYSCAN 0x0a82U // Syscan
#define UHS_VID_NEXTCOMM 0x0a83U // NextComm, Inc.
#define UHS_VID_MAUI_INNOVATIVE_PERIPHERALS 0x0a84U // Maui Innovative Peripherals
#define UHS_VID_IDEXX_LABS 0x0a85U // Idexx Labs
#define UHS_VID_NITGEN 0x0a86U // NITGen Co., Ltd
#define UHS_VID_AKTIV 0x0a89U // Aktiv
#define UHS_VID_PICTURETEL 0x0a8dU // Picturetel
#define UHS_VID_JAPAN_AVIATION_ELECTRONICS_INDUSTRY 0x0a8eU // Japan Aviation Electronics Industry, Ltd
#define UHS_VID_CANDY_TECHNOLOGY 0x0a90U // Candy Technology Co., Ltd
#define UHS_VID_GLOBLINK_TECHNOLOGY 0x0a91U // Globlink Technology, Inc.
#define UHS_VID_EGO_SYSTEMS 0x0a92U // EGO SYStems, Inc.
#define UHS_VID_C_TECHNOLOGIES 0x0a93U // C Technologies AB
#define UHS_VID_INTERSENSE 0x0a94U // Intersense
#define UHS_VID_LAVA_COMPUTER_MFG 0x0aa3U // Lava Computer Mfg., Inc.
#define UHS_VID_DEVELCO_ELEKTRONIK 0x0aa4U // Develco Elektronik
#define UHS_VID_FIRST_INTERNATIONAL_DIGITAL 0x0aa5U // First International Digital
#define UHS_VID_PERCEPTION_DIGITAL 0x0aa6U // Perception Digital, Ltd
#define UHS_VID_WINCOR_NIXDORF_INTERNATIONAL 0x0aa7U // Wincor Nixdorf International GmbH
#define UHS_VID_TRIGEM_COMPUTER 0x0aa8U // TriGem Computer, Inc.
#define UHS_VID_BAROMTEC 0x0aa9U // Baromtec Co.
#define UHS_VID_JAPAN_CBM 0x0aaaU // Japan CBM Corp.
#define UHS_VID_VISION_SHAPE_EUROPE 0x0aabU // Vision Shape Europe SA
#define UHS_VID_ICOMPRESSION 0x0aacU // iCompression, Inc.
#define UHS_VID_ROHDE_AND_SCHWARZ_GMBH_AND_CO_KG 0x0aadU // Rohde & Schwarz GmbH & Co. KG
#define UHS_VID_NEC_INFRONTIA_CORP_NITSUKO 0x0aaeU // NEC infrontia Corp. (Nitsuko)
#define UHS_VID_DIGITALWAY 0x0aafU // Digitalway Co., Ltd
#define UHS_VID_ARROW_STRONG_ELECTRONICS 0x0ab0U // Arrow Strong Electronics Co., Ltd
#define UHS_VID_FEIG_ELECTRONIC 0x0ab1U // FEIG ELECTRONIC GmbH
#define UHS_VID_ELLISYS 0x0abaU // Ellisys
#define UHS_VID_STEREO_LINK 0x0abeU // Stereo-Link
#define UHS_VID_DIOLAN 0x0abfU // Diolan
#define UHS_VID_SANYO_SEMICONDUCTOR_COMPANY_MICRO 0x0ac3U // Sanyo Semiconductor Company Micro
#define UHS_VID_LECO 0x0ac4U // Leco Corp.
#define UHS_VID_I_AND_C 0x0ac5U // I & C Corp.
#define UHS_VID_SINGING_ELECTRONS 0x0ac6U // Singing Electrons, Inc.
#define UHS_VID_PANWEST 0x0ac7U // Panwest Corp.
#define UHS_VID_Z_STAR_MICROELECTRONICS 0x0ac8U // Z-Star Microelectronics Corp.
#define UHS_VID_MICRO_SOLUTIONS 0x0ac9U // Micro Solutions, Inc.
#define UHS_VID_OPEN_NETWORKS 0x0acaU // OPEN Networks Ltd
#define UHS_VID_KOGA_ELECTRONICS 0x0accU // Koga Electronics Co.
#define UHS_VID_ID_TECH 0x0acdU // ID Tech
#define UHS_VID_ZYDAS 0x0aceU // ZyDAS
#define UHS_VID_INTOTO 0x0acfU // Intoto, Inc.
#define UHS_VID_INTELLIX 0x0ad0U // Intellix Corp.
#define UHS_VID_REMOTEC_TECHNOLOGY 0x0ad1U // Remotec Technology, Ltd
#define UHS_VID_SERVICE_AND_QUALITY_TECHNOLOGY 0x0ad2U // Service & Quality Technology Co., Ltd
#define UHS_VID_DATA_ENCRYPTION_SYSTEMS 0x0adaU // Data Encryption Systems Ltd.
#define UHS_VID_ALLION_COMPUTER 0x0ae3U // Allion Computer, Inc.
#define UHS_VID_TAITO 0x0ae4U // Taito Corp.
#define UHS_VID_NEODYM_SYSTEMS 0x0ae7U // Neodym Systems, Inc.
#define UHS_VID_SYSTEM_SUPPORT 0x0ae8U // System Support Co., Ltd
#define UHS_VID_NORTH_SHORE_CIRCUIT_DESIGN_LLP 0x0ae9U // North Shore Circuit Design L.L.P.
#define UHS_VID_SCIESSENCE 0x0aeaU // SciEssence, LLC
#define UHS_VID_TTP_COMMUNICATIONS 0x0aebU // TTP Communications, Ltd
#define UHS_VID_NEODIO_TECHNOLOGIES 0x0aecU // Neodio Technologies Corp.
#define UHS_VID_OPTION 0x0af0U // Option
#define UHS_VID_SILVER_I 0x0af6U // Silver I Co., Ltd
#define UHS_VID_B2C2 0x0af7U // B2C2, Inc.
#define UHS_VID_HAMA 0x0af9U // Hama, Inc.
#define UHS_VID_DMC 0x0afaU // DMC Co., Ltd.
#define UHS_VID_ZAPTRONIX 0x0afcU // Zaptronix Ltd
#define UHS_VID_TATENO_DENNOU 0x0afdU // Tateno Dennou, Inc.
#define UHS_VID_CUMMINS_ENGINE 0x0afeU // Cummins Engine Co.
#define UHS_VID_JUMP_ZONE_NETWORK_PRODUCTS 0x0affU // Jump Zone Network Products, Inc.
#define UHS_VID_INGENICO 0x0b00U // INGENICO
#define UHS_VID_ASUSTEK_COMPUTER 0x0b05U // ASUSTek Computer, Inc.
#define UHS_VID_DATAMAX_ONEIL 0x0b0bU // Datamax-O'Neil
#define UHS_VID_TODOS 0x0b0cU // Todos AB
#define UHS_VID_PROJECTLAB 0x0b0dU // ProjectLab
#define UHS_VID_GN_NETCOM 0x0b0eU // GN Netcom
#define UHS_VID_AVID_TECHNOLOGY 0x0b0fU // AVID Technology
#define UHS_VID_PCALLY 0x0b10U // Pcally
#define UHS_VID_I_TECH_SOLUTIONS 0x0b11U // I Tech Solutions Co., Ltd
#define UHS_VID_ELECTRONIC_WARFARE_ASSOC_INC_EWA 0x0b1eU // Electronic Warfare Assoc., Inc. (EWA)
#define UHS_VID_INSYDE_SOFTWARE 0x0b1fU // Insyde Software Corp.
#define UHS_VID_TRANSDIMENSION 0x0b20U // TransDimension, Inc.
#define UHS_VID_YOKOGAWA_ELECTRIC 0x0b21U // Yokogawa Electric Corp.
#define UHS_VID_JAPAN_SYSTEM_DEVELOPMENT 0x0b22U // Japan System Development Co., Ltd
#define UHS_VID_PAN_ASIA_ELECTRONICS 0x0b23U // Pan-Asia Electronics Co., Ltd
#define UHS_VID_LINK_EVOLUTION 0x0b24U // Link Evolution Corp.
#define UHS_VID_RITEK 0x0b27U // Ritek Corp.
#define UHS_VID_KENWOOD 0x0b28U // Kenwood Corp.
#define UHS_VID_VILLAGE_CENTER 0x0b2cU // Village Center, Inc.
#define UHS_VID_PNY_TECHNOLOGIES 0x0b30U // PNY Technologies, Inc.
#define UHS_VID_CONTOUR_DESIGN 0x0b33U // Contour Design, Inc.
#define UHS_VID_HITACHI_ULSI_SYSTEMS 0x0b37U // Hitachi ULSI Systems Co., Ltd
#define UHS_VID_GEAR_HEAD 0x0b38U // Gear Head
#define UHS_VID_OMNIDIRECTIONAL_CONTROL_TECHNOLOGY 0x0b39U // Omnidirectional Control Technology, Inc.
#define UHS_VID_IPAXESS 0x0b3aU // IPaxess
#define UHS_VID_TEKRAM_TECHNOLOGY 0x0b3bU // Tekram Technology Co., Ltd
#define UHS_VID_OLIVETTI_TECHCENTER 0x0b3cU // Olivetti Techcenter
#define UHS_VID_KIKUSUI_ELECTRONICS 0x0b3eU // Kikusui Electronics Corp.
#define UHS_VID_HAL 0x0b41U // Hal Corp.
#define UHS_VID_PLAYCOM 0x0b43U // Play.com, Inc.
#define UHS_VID_SPORTBUGCOM 0x0b47U // Sportbug.com, Inc.
#define UHS_VID_TECHNOTREND_AG 0x0b48U // TechnoTrend AG
#define UHS_VID_ASCII 0x0b49U // ASCII Corp.
#define UHS_VID_PINE 0x0b4bU // Pine Corp. Ltd.
#define UHS_VID_GRAPHTEC_AMERICA 0x0b4dU // Graphtec America, Inc.
#define UHS_VID_MUSICAL_ELECTRONICS 0x0b4eU // Musical Electronics, Ltd
#define UHS_VID_DUMPRIES 0x0b50U // Dumpries Co., Ltd
#define UHS_VID_COMFORT_KEYBOARD 0x0b51U // Comfort Keyboard Co.
#define UHS_VID_COLORADO_MICRODISPLAY 0x0b52U // Colorado MicroDisplay, Inc.
#define UHS_VID_SINBON_ELECTRONICS 0x0b54U // Sinbon Electronics Co., Ltd
#define UHS_VID_TYI_SYSTEMS 0x0b56U // TYI Systems, Ltd
#define UHS_VID_BEIJING_HANWANGTECHNOLOGY 0x0b57U // Beijing HanwangTechnology Co., Ltd
#define UHS_VID_LAKE_COMMUNICATIONS 0x0b59U // Lake Communications, Ltd
#define UHS_VID_COREL 0x0b5aU // Corel Corp.
#define UHS_VID_GREEN_ELECTRONICS 0x0b5fU // Green Electronics Co., Ltd
#define UHS_VID_NSINE 0x0b60U // Nsine, Ltd
#define UHS_VID_NEC_VIEWTECHNOLOGY 0x0b61U // NEC Viewtechnology, Ltd
#define UHS_VID_ORANGE_MICRO 0x0b62U // Orange Micro, Inc.
#define UHS_VID_ADLINK_TECHNOLOGY 0x0b63U // ADLink Technology, Inc.
#define UHS_VID_WONDERFUL_WIRE_CABLE 0x0b64U // Wonderful Wire Cable Co., Ltd
#define UHS_VID_EXPERT_MAGNETICS 0x0b65U // Expert Magnetics Corp.
#define UHS_VID_CYBIKO 0x0b66U // Cybiko Inc.
#define UHS_VID_FAIRBANKS_SCALES 0x0b67U // Fairbanks Scales
#define UHS_VID_CACHEVISION 0x0b69U // CacheVision
#define UHS_VID_MAXIM_INTEGRATED_PRODUCTS 0x0b6aU // Maxim Integrated Products
#define UHS_VID_NAGANO_JAPAN_RADIO 0x0b6fU // Nagano Japan Radio Co., Ltd
#define UHS_VID_PORTALPLAYER 0x0b70U // PortalPlayer, Inc.
#define UHS_VID_SHIN_EI_SANGYO 0x0b71U // SHIN-EI Sangyo Co., Ltd
#define UHS_VID_EMBEDDED_WIRELESS_TECHNOLOGY 0x0b72U // Embedded Wireless Technology Co., Ltd
#define UHS_VID_COMPUTONE 0x0b73U // Computone Corp.
#define UHS_VID_ROLAND_DG 0x0b75U // Roland DG Corp.
#define UHS_VID_SUNRISE_TELECOM 0x0b79U // Sunrise Telecom, Inc.
#define UHS_VID_ZEEVO 0x0b7aU // Zeevo, Inc.
#define UHS_VID_TAIKO_DENKI 0x0b7bU // Taiko Denki Co., Ltd
#define UHS_VID_ITRAN_COMMUNICATIONS 0x0b7cU // ITRAN Communications, Ltd
#define UHS_VID_ASTRODESIGN 0x0b7dU // Astrodesign, Inc.
#define UHS_VID_ID3_TECHNOLOGIES 0x0b81U // id3 Technologies
#define UHS_VID_REXTRON_TECHNOLOGY 0x0b84U // Rextron Technology, Inc.
#define UHS_VID_ELKAT_ELECTRONICS_SDN_BHD 0x0b85U // Elkat Electronics, Sdn., Bhd.
#define UHS_VID_EXPUTER_SYSTEMS 0x0b86U // Exputer Systems, Inc.
#define UHS_VID_PLUS_ONE_I_AND_T 0x0b87U // Plus-One I & T, Inc.
#define UHS_VID_SIGMA_KOKI_CO_LTD_TECHNOLOGY_CENTER 0x0b88U // Sigma Koki Co., Ltd, Technology Center
#define UHS_VID_ADVANCED_DIGITAL_BROADCAST 0x0b89U // Advanced Digital Broadcast, Ltd
#define UHS_VID_SMART_TECHNOLOGIES 0x0b8cU // SMART Technologies Inc.
#define UHS_VID_ASIX_ELECTRONICS 0x0b95U // ASIX Electronics Corp.
#define UHS_VID_SEWON_TELECOM 0x0b96U // Sewon Telecom
#define UHS_VID_O2_MICRO 0x0b97U // O2 Micro, Inc.
#define UHS_VID_PLAYMATES_TOYS 0x0b98U // Playmates Toys, Inc.
#define UHS_VID_AUDIO_INTERNATIONAL 0x0b99U // Audio International, Inc.
#define UHS_VID_DIPL_ING_STEFAN_KUNDE 0x0b9bU // Dipl.-Ing. Stefan Kunde
#define UHS_VID_SOFTPROTEC 0x0b9dU // Softprotec Co.
#define UHS_VID_CHIPPO_TECHNOLOGIES 0x0b9fU // Chippo Technologies
#define UHS_VID_US_ROBOTICS 0x0bafU // U.S. Robotics
#define UHS_VID_CONCORD_CAMERA 0x0bb0U // Concord Camera Corp.
#define UHS_VID_INFINILINK 0x0bb1U // Infinilink Corp.
#define UHS_VID_AMBIT_MICROSYSTEMS 0x0bb2U // Ambit Microsystems Corp.
#define UHS_VID_OFUJI_TECHNOLOGY 0x0bb3U // Ofuji Technology
#define UHS_VID_HTC_HIGH_TECH_COMPUTER 0x0bb4U // HTC (High Tech Computer Corp.)
#define UHS_VID_MURATA_MANUFACTURING 0x0bb5U // Murata Manufacturing Co., Ltd
#define UHS_VID_NETWORK_ALCHEMY 0x0bb6U // Network Alchemy
#define UHS_VID_JOYTECH_COMPUTER 0x0bb7U // Joytech Computer Co., Ltd
#define UHS_VID_HITACHI_SEMICONDUCTOR_AND_DEVICES_SALES 0x0bb8U // Hitachi Semiconductor and Devices Sales Co., Ltd
#define UHS_VID_EIGER_MANDC 0x0bb9U // Eiger M&C Co., Ltd
#define UHS_VID_ZACCESS_SYSTEMS 0x0bbaU // ZAccess Systems
#define UHS_VID_GENERAL_METERS 0x0bbbU // General Meters Corp.
#define UHS_VID_ASSISTIVE_TECHNOLOGY 0x0bbcU // Assistive Technology, Inc.
#define UHS_VID_SYSTEM_CONNECTION 0x0bbdU // System Connection, Inc.
#define UHS_VID_KNILINK_TECHNOLOGY 0x0bc0U // Knilink Technology, Inc.
#define UHS_VID_FUW_YNG_ELECTRONICS 0x0bc1U // Fuw Yng Electronics Co., Ltd
#define UHS_VID_SEAGATE_RSS 0x0bc2U // Seagate RSS LLC
#define UHS_VID_IPWIRELESS 0x0bc3U // IPWireless, Inc.
#define UHS_VID_MICROCUBE 0x0bc4U // Microcube Corp.
#define UHS_VID_JCN 0x0bc5U // JCN Co., Ltd
#define UHS_VID_EXWAY 0x0bc6U // ExWAY, Inc.
#define UHS_VID_X10_WIRELESS_TECHNOLOGY 0x0bc7U // X10 Wireless Technology, Inc.
#define UHS_VID_TELMAX_COMMUNICATIONS 0x0bc8U // Telmax Communications
#define UHS_VID_ECI_TELECOM 0x0bc9U // ECI Telecom, Ltd
#define UHS_VID_STARTEK_ENGINEERING 0x0bcaU // Startek Engineering, Inc.
#define UHS_VID_PERFECT_TECHNIC_ENTERPRISE 0x0bcbU // Perfect Technic Enterprise Co., Ltd
#define UHS_VID_ANDREW_PARGETER_AND_ASSOCIATES 0x0bd7U // Andrew Pargeter & Associates
#define UHS_VID_REALTEK_SEMICONDUCTOR 0x0bdaU // Realtek Semiconductor Corp.
#define UHS_VID_ERICSSON_BUSINESS_MOBILE_NETWORKS_BV 0x0bdbU // Ericsson Business Mobile Networks BV
#define UHS_VID_Y_MEDIA 0x0bdcU // Y Media Corp.
#define UHS_VID_ORANGE_PCS 0x0bddU // Orange PCS
#define UHS_VID_KANDA_TSUSHIN_KOGYO 0x0be2U // Kanda Tsushin Kogyo Co., Ltd
#define UHS_VID_TOYO 0x0be3U // TOYO Corp.
#define UHS_VID_ELKA_INTERNATIONAL 0x0be4U // Elka International, Ltd
#define UHS_VID_DOME_IMAGING_SYSTEMS 0x0be5U // DOME imaging systems, Inc.
#define UHS_VID_DONG_GUAN_HUMEN_WONDERFUL_WIRE_CABLE_FACTORY 0x0be6U // Dong Guan Humen Wonderful Wire Cable Factory
#define UHS_VID_MEI 0x0bedU // MEI
#define UHS_VID_LTK_INDUSTRIES 0x0beeU // LTK Industries, Ltd
#define UHS_VID_WAY2CALL_COMMUNICATIONS 0x0befU // Way2Call Communications
#define UHS_VID_PACE_MICRO_TECHNOLOGY_PLC 0x0bf0U // Pace Micro Technology PLC
#define UHS_VID_INTRACOM 0x0bf1U // Intracom S.A.
#define UHS_VID_KONEXX 0x0bf2U // Konexx
#define UHS_VID_ADDONICS_TECHNOLOGIES_1 0x0bf6U // Addonics Technologies, Inc.
#define UHS_VID_SUNNY_GIKEN 0x0bf7U // Sunny Giken, Inc.
#define UHS_VID_FUJITSU_SIEMENS_COMPUTERS_1 0x0bf8U // Fujitsu Siemens Computers
#define UHS_VID_KVASER 0x0bfdU // Kvaser AB
#define UHS_VID_MOTO_DEVELOPMENT_GROUP 0x0c04U // MOTO Development Group, Inc.
#define UHS_VID_APPIAN_GRAPHICS 0x0c05U // Appian Graphics
#define UHS_VID_HASBRO_GAMES 0x0c06U // Hasbro Games, Inc.
#define UHS_VID_INFINITE_DATA_STORAGE 0x0c07U // Infinite Data Storage, Ltd
#define UHS_VID_AGATE 0x0c08U // Agate
#define UHS_VID_COMJET_INFORMATION_SYSTEM 0x0c09U // Comjet Information System
#define UHS_VID_HIGHPOINT_TECHNOLOGIES 0x0c0aU // Highpoint Technologies, Inc.
#define UHS_VID_DURA_MICRO_INC_ACOMDATA 0x0c0bU // Dura Micro, Inc. (Acomdata)
#define UHS_VID_ZEROPLUS 0x0c12U // Zeroplus
#define UHS_VID_IRIS_GRAPHICS 0x0c15U // Iris Graphics
#define UHS_VID_GYRATION 0x0c16U // Gyration, Inc.
#define UHS_VID_CYBERBOARD_AS 0x0c17U // Cyberboard A/S
#define UHS_VID_SYNERTEK_KOREA 0x0c18U // SynerTek Korea, Inc.
#define UHS_VID_CYBERPIXIE 0x0c19U // cyberPIXIE, Inc.
#define UHS_VID_SILICON_MOTION 0x0c1aU // Silicon Motion, Inc.
#define UHS_VID_MIPS_TECHNOLOGIES 0x0c1bU // MIPS Technologies
#define UHS_VID_HANG_ZHOU_SILAN_ELECTRONICS 0x0c1cU // Hang Zhou Silan Electronics Co., Ltd
#define UHS_VID_TALLY_PRINTER 0x0c22U // Tally Printer Corp.
#define UHS_VID_LERNOUT__HAUSPIE 0x0c23U // Lernout + Hauspie
#define UHS_VID_TAIYO_YUDEN 0x0c24U // Taiyo Yuden
#define UHS_VID_SAMPO 0x0c25U // Sampo Corp.
#define UHS_VID_PROLIFIC_TECHNOLOGY_1 0x0c26U // Prolific Technology Inc.
#define UHS_VID_RFIDEAS 0x0c27U // RFIDeas, Inc
#define UHS_VID_METROLOGIC_INSTRUMENTS 0x0c2eU // Metrologic Instruments
#define UHS_VID_EAGLETRON 0x0c35U // Eagletron, Inc.
#define UHS_VID_E_INK 0x0c36U // E Ink Corp.
#define UHS_VID_EDIGITAL 0x0c37U // e.Digital
#define UHS_VID_DER_AN_ELECTRIC_WIRE_AND_CABLE 0x0c38U // Der An Electric Wire & Cable Co., Ltd
#define UHS_VID_IFR 0x0c39U // IFR
#define UHS_VID_FURUI_PRECISE_COMPONENT_KUNSHAN 0x0c3aU // Furui Precise Component (Kunshan) Co., Ltd
#define UHS_VID_KOMATSU 0x0c3bU // Komatsu, Ltd
#define UHS_VID_RADIUS 0x0c3cU // Radius Co., Ltd
#define UHS_VID_INNOCOM 0x0c3dU // Innocom, Inc.
#define UHS_VID_NEXTCELL 0x0c3eU // Nextcell, Inc.
#define UHS_VID_MOTOROLA_IDEN 0x0c44U // Motorola iDEN
#define UHS_VID_MICRODIA 0x0c45U // Microdia
#define UHS_VID_WAVERIDER_COMMUNICATIONS 0x0c46U // WaveRider Communications, Inc.
#define UHS_VID_ALGE_TIMING 0x0c4aU // ALGE-TIMING GmbH
#define UHS_VID_REINER_SCT_KARTENSYSTEME 0x0c4bU // Reiner SCT Kartensysteme GmbH
#define UHS_VID_NEEDHAMS_ELECTRONICS 0x0c4cU // Needham's Electronics
#define UHS_VID_SEALEVEL_SYSTEMS 0x0c52U // Sealevel Systems, Inc.
#define UHS_VID_VIEWPLUS 0x0c53U // ViewPLUS, Inc.
#define UHS_VID_GLORY 0x0c54U // Glory, Ltd
#define UHS_VID_SPECTRUM_DIGITAL 0x0c55U // Spectrum Digital, Inc.
#define UHS_VID_BILLION_BRIGHT 0x0c56U // Billion Bright, Ltd
#define UHS_VID_IMAGINATIVE_DESIGN_OPERATION 0x0c57U // Imaginative Design Operation Co., Ltd
#define UHS_VID_VIDAR_SYSTEMS 0x0c58U // Vidar Systems Corp.
#define UHS_VID_DONG_GUAN_SHINKO_WIRE 0x0c59U // Dong Guan Shinko Wire Co., Ltd
#define UHS_VID_TRS_INTERNATIONAL_MFG 0x0c5aU // TRS International Mfg., Inc.
#define UHS_VID_XYTRONIX_RESEARCH_AND_DESIGN 0x0c5eU // Xytronix Research & Design
#define UHS_VID_APOGEE_ELECTRONICS 0x0c60U // Apogee Electronics Corp.
#define UHS_VID_CHANT_SINCERE 0x0c62U // Chant Sincere Co., Ltd
#define UHS_VID_TOKO 0x0c63U // Toko, Inc.
#define UHS_VID_SIGNALITY_SYSTEM_ENGINEERING 0x0c64U // Signality System Engineering Co., Ltd
#define UHS_VID_EMINENCE_ENTERPRISE 0x0c65U // Eminence Enterprise Co., Ltd
#define UHS_VID_REXON_ELECTRONICS 0x0c66U // Rexon Electronics Corp.
#define UHS_VID_CONCEPT_TELECOM 0x0c67U // Concept Telecom, Ltd
#define UHS_VID_ACS 0x0c6aU // ACS
#define UHS_VID_JETI_TECHNISCHE_INSTRUMENTE 0x0c6cU // JETI Technische Instrumente GmbH
#define UHS_VID_MCT_ELEKTRONIKLADEN 0x0c70U // MCT Elektronikladen
#define UHS_VID_PEAK_SYSTEM 0x0c72U // PEAK System
#define UHS_VID_OPTRONIC_LABORATORIES 0x0c74U // Optronic Laboratories Inc.
#define UHS_VID_JMTEK 0x0c76U // JMTek, LLC.
#define UHS_VID_SIPIX_GROUP 0x0c77U // Sipix Group, Ltd
#define UHS_VID_DETTO 0x0c78U // Detto Corp.
#define UHS_VID_NUCONNEX_TECHNOLOGIES_PTE 0x0c79U // NuConnex Technologies Pte., Ltd
#define UHS_VID_WING_SPAN_ENTERPRISE 0x0c7aU // Wing-Span Enterprise Co., Ltd
#define UHS_VID_NDA_TECHNOLOGIES 0x0c86U // NDA Technologies, Inc.
#define UHS_VID_KYOCERA_WIRELESS 0x0c88U // Kyocera Wireless Corp.
#define UHS_VID_HONDA_TSUSHIN_KOGYO 0x0c89U // Honda Tsushin Kogyo Co., Ltd
#define UHS_VID_PATHWAY_CONNECTIVITY 0x0c8aU // Pathway Connectivity, Inc.
#define UHS_VID_WAVEFLY 0x0c8bU // Wavefly Corp.
#define UHS_VID_COACTIVE_NETWORKS 0x0c8cU // Coactive Networks
#define UHS_VID_TEMPO 0x0c8dU // Tempo
#define UHS_VID_CESSCOM 0x0c8eU // Cesscom Co., Ltd
#define UHS_VID_APPLIED_MICROSYSTEMS 0x0c8fU // Applied Microsystems
#define UHS_VID_CRYPTERA 0x0c94U // Cryptera
#define UHS_VID_BERKSHIRE_PRODUCTS 0x0c98U // Berkshire Products, Inc.
#define UHS_VID_INNOCHIPS 0x0c99U // Innochips Co., Ltd
#define UHS_VID_HANWOOL_ROBOTICS 0x0c9aU // Hanwool Robotics Corp.
#define UHS_VID_JOBIN_YVON 0x0c9bU // Jobin Yvon, Inc.
#define UHS_VID_SEMTEK 0x0c9dU // SemTek
#define UHS_VID_ZYFER 0x0ca2U // Zyfer
#define UHS_VID_SEGA 0x0ca3U // Sega Corp.
#define UHS_VID_STANDT_INSTRUMENT 0x0ca4U // ST&T Instrument Corp.
#define UHS_VID_BAE_SYSTEMS_CANADA 0x0ca5U // BAE Systems Canada, Inc.
#define UHS_VID_CASTLES_TECHNOLOGY 0x0ca6U // Castles Technology Co., Ltd
#define UHS_VID_INFORMATION_SYSTEMS_LABORATORIES 0x0ca7U // Information Systems Laboratories
#define UHS_VID_MOTOROLA_CGISS 0x0cadU // Motorola CGISS
#define UHS_VID_ASCOM_BUSINESS_SYSTEMS 0x0caeU // Ascom Business Systems, Ltd
#define UHS_VID_BUSLINK 0x0cafU // Buslink
#define UHS_VID_FLYING_PIG_SYSTEMS 0x0cb0U // Flying Pig Systems
#define UHS_VID_INNOVONICS 0x0cb1U // Innovonics, Inc.
#define UHS_VID_CELESTIX_NETWORKS_PTE 0x0cb6U // Celestix Networks, Pte., Ltd
#define UHS_VID_SINGATRON_ENTERPRISE 0x0cb7U // Singatron Enterprise Co., Ltd
#define UHS_VID_OPTICIS 0x0cb8U // Opticis Co., Ltd
#define UHS_VID_TRUST_ELECTRONIC_SHANGHAI 0x0cbaU // Trust Electronic (Shanghai) Co., Ltd
#define UHS_VID_SHANGHAI_DARONG_ELECTRONICS 0x0cbbU // Shanghai Darong Electronics Co., Ltd
#define UHS_VID_PALMAX_TECHNOLOGY 0x0cbcU // Palmax Technology Co., Ltd
#define UHS_VID_PENTEL_CO_LTD_ELECTRONICS_EQUIPMENT_DIV 0x0cbdU // Pentel Co., Ltd (Electronics Equipment Div.)
#define UHS_VID_KERYX_TECHNOLOGIES 0x0cbeU // Keryx Technologies, Inc.
#define UHS_VID_UNION_GENIUS_COMPUTER 0x0cbfU // Union Genius Computer Co., Ltd
#define UHS_VID_KUON_YI_INDUSTRIAL 0x0cc0U // Kuon Yi Industrial Corp.
#define UHS_VID_GIVEN_IMAGING 0x0cc1U // Given Imaging, Ltd
#define UHS_VID_TIMEX 0x0cc2U // Timex Corp.
#define UHS_VID_RIMAGE 0x0cc3U // Rimage Corp.
#define UHS_VID_EMSYS 0x0cc4U // emsys GmbH
#define UHS_VID_SENDO 0x0cc5U // Sendo
#define UHS_VID_INTERMAGIC 0x0cc6U // Intermagic Corp.
#define UHS_VID_KONTRON_MEDICAL_AG 0x0cc7U // Kontron Medical AG
#define UHS_VID_TECHNOTOOLS 0x0cc8U // Technotools Corp.
#define UHS_VID_BROADMAX_TECHNOLOGIES 0x0cc9U // BroadMAX Technologies, Inc.
#define UHS_VID_AMPHENOL 0x0ccaU // Amphenol
#define UHS_VID_SKNET 0x0ccbU // SKNet Co., Ltd
#define UHS_VID_DOMEX_TECHNOLOGY 0x0cccU // Domex Technology Corp.
#define UHS_VID_TERRATEC_ELECTRONIC 0x0ccdU // TerraTec Electronic GmbH
#define UHS_VID_BANG_OLUFSEN 0x0cd4U // Bang Olufsen
#define UHS_VID_LABJACK_CORPORATION 0x0cd5U // LabJack Corporation
#define UHS_VID_NEWCHIP_SRL 0x0cd7U // NewChip S.r.l.
#define UHS_VID_JS_DIGITECH 0x0cd8U // JS Digitech, Inc.
#define UHS_VID_HITACHI_SHIN_DIN_CABLE 0x0cd9U // Hitachi Shin Din Cable, Ltd
#define UHS_VID_Z_COM 0x0cdeU // Z-Com
#define UHS_VID_VALIDATION_TECHNOLOGIES_INTERNATIONAL 0x0ce5U // Validation Technologies International
#define UHS_VID_PICO_TECHNOLOGY 0x0ce9U // Pico Technology
#define UHS_VID_E_CONN_ELECTRONIC 0x0cf1U // e-Conn Electronic Co., Ltd
#define UHS_VID_ENE_TECHNOLOGY 0x0cf2U // ENE Technology, Inc.
#define UHS_VID_ATHEROS_COMMUNICATIONS 0x0cf3U // Atheros Communications, Inc.
#define UHS_VID_FOMTEX 0x0cf4U // Fomtex Corp.
#define UHS_VID_CELLINK 0x0cf5U // Cellink Co., Ltd
#define UHS_VID_COMPUCABLE 0x0cf6U // Compucable Corp.
#define UHS_VID_ISHONI_NETWORKS 0x0cf7U // ishoni Networks
#define UHS_VID_CLARISYS 0x0cf8U // Clarisys, Inc.
#define UHS_VID_CENTRAL_SYSTEM_RESEARCH 0x0cf9U // Central System Research Co., Ltd
#define UHS_VID_INVISO 0x0cfaU // Inviso, Inc.
#define UHS_VID_MINOLTA_QMS 0x0cfcU // Minolta-QMS, Inc.
#define UHS_VID_SAFA_MEDIA 0x0cffU // SAFA MEDIA Co., Ltd.
#define UHS_VID_TELOS_EDV_SYSTEMENTWICKLUNG 0x0d06U // telos EDV Systementwicklung GmbH
#define UHS_VID_UTSTARCOM 0x0d08U // UTStarcom
#define UHS_VID_CONTEMPORARY_CONTROLS 0x0d0bU // Contemporary Controls
#define UHS_VID_ASTRON_ELECTRONICS 0x0d0cU // Astron Electronics Co., Ltd
#define UHS_VID_MKNET 0x0d0dU // MKNet Corp.
#define UHS_VID_HYBRID_NETWORKS 0x0d0eU // Hybrid Networks, Inc.
#define UHS_VID_FENG_SHIN_CABLE 0x0d0fU // Feng Shin Cable Co., Ltd
#define UHS_VID_ELASTIC_NETWORKS 0x0d10U // Elastic Networks
#define UHS_VID_MASPRO_DENKOH 0x0d11U // Maspro Denkoh Corp.
#define UHS_VID_HANSOL_ELECTRONICS 0x0d12U // Hansol Electronics, Inc.
#define UHS_VID_BMF 0x0d13U // BMF Corp.
#define UHS_VID_ARRAY_COMM 0x0d14U // Array Comm, Inc.
#define UHS_VID_ONSTREAM_BV 0x0d15U // OnStream b.v.
#define UHS_VID_HI_TOUCH_IMAGING_TECHNOLOGIES 0x0d16U // Hi-Touch Imaging Technologies Co., Ltd
#define UHS_VID_NALTEC 0x0d17U // NALTEC, Inc.
#define UHS_VID_COAXMEDIA 0x0d18U // coaXmedia
#define UHS_VID_HANK_CONNECTION_INDUSTRIAL 0x0d19U // Hank Connection Industrial Co., Ltd
#define UHS_VID_NXP 0x0d28U // NXP
#define UHS_VID_LEO_HUI_ELECTRIC_WIRE_AND_CABLE 0x0d32U // Leo Hui Electric Wire & Cable Co., Ltd
#define UHS_VID_AIRSPEAK 0x0d33U // AirSpeak, Inc.
#define UHS_VID_REARDEN_STEEL_TECHNOLOGIES 0x0d34U // Rearden Steel Technologies
#define UHS_VID_DAH_KUN 0x0d35U // Dah Kun Co., Ltd
#define UHS_VID_POSIFLEX_TECHNOLOGIES 0x0d3aU // Posiflex Technologies, Inc.
#define UHS_VID_SRI_CABLE_TECHNOLOGY 0x0d3cU // Sri Cable Technology, Ltd
#define UHS_VID_TANGTOP_TECHNOLOGY 0x0d3dU // Tangtop Technology Co., Ltd
#define UHS_VID_FITCOM 0x0d3eU // Fitcom, inc.
#define UHS_VID_MTS_SYSTEMS 0x0d3fU // MTS Systems Corp.
#define UHS_VID_ASCOR 0x0d40U // Ascor, Inc.
#define UHS_VID_TA_YUN_TERMINALS_INDUSTRIAL 0x0d41U // Ta Yun Terminals Industrial Co., Ltd
#define UHS_VID_FULL_DER 0x0d42U // Full Der Co., Ltd
#define UHS_VID_KOBIL_SYSTEMS 0x0d46U // Kobil Systems GmbH
#define UHS_VID_PROMETHEAN_LIMITED 0x0d48U // Promethean Limited
#define UHS_VID_MAXTOR 0x0d49U // Maxtor
#define UHS_VID_NF 0x0d4aU // NF Corp.
#define UHS_VID_GRAPE_SYSTEMS 0x0d4bU // Grape Systems, Inc.
#define UHS_VID_TEDAS_AG 0x0d4cU // Tedas AG
#define UHS_VID_COHERENT 0x0d4dU // Coherent, Inc.
#define UHS_VID_AGERE_SYSTEMS_NETHERLAND_BV 0x0d4eU // Agere Systems Netherland BV
#define UHS_VID_EADS_AIRBUS_FRANCE 0x0d4fU // EADS Airbus France
#define UHS_VID_CLEWARE 0x0d50U // Cleware GmbH
#define UHS_VID_VOLEX_ASIA_PTE 0x0d51U // Volex (Asia) Pte., Ltd
#define UHS_VID_HMI 0x0d53U // HMI Co., Ltd
#define UHS_VID_HOLON 0x0d54U // Holon Corp.
#define UHS_VID_ASKA_TECHNOLOGIES 0x0d55U // ASKA Technologies, Inc.
#define UHS_VID_AVLAB_TECHNOLOGY 0x0d56U // AVLAB Technology, Inc.
#define UHS_VID_SOLOMON_MICROTECH 0x0d57U // Solomon Microtech, Ltd
#define UHS_VID_SMC_NETWORKS 0x0d5cU // SMC Networks, Inc.
#define UHS_VID_MYACOM 0x0d5eU // Myacom, Ltd
#define UHS_VID_CSI 0x0d5fU // CSI, Inc.
#define UHS_VID_IVL_TECHNOLOGIES 0x0d60U // IVL Technologies, Ltd
#define UHS_VID_MEILU_ELECTRONICS_SHENZHEN 0x0d61U // Meilu Electronics (Shenzhen) Co., Ltd
#define UHS_VID_DARFON_ELECTRONICS 0x0d62U // Darfon Electronics Corp.
#define UHS_VID_FRITZ_GEGAUF_AG 0x0d63U // Fritz Gegauf AG
#define UHS_VID_DXG_TECHNOLOGY 0x0d64U // DXG Technology Corp.
#define UHS_VID_KMJP 0x0d65U // KMJP Co., Ltd
#define UHS_VID_TMT 0x0d66U // TMT
#define UHS_VID_ADVANET 0x0d67U // Advanet, Inc.
#define UHS_VID_SUPER_LINK_ELECTRONICS 0x0d68U // Super Link Electronics Co., Ltd
#define UHS_VID_NSI 0x0d69U // NSI
#define UHS_VID_MEGAPOWER_INTERNATIONAL 0x0d6aU // Megapower International Corp.
#define UHS_VID_AND_OR_LOGIC 0x0d6bU // And-Or Logic
#define UHS_VID_TRY_COMPUTER 0x0d70U // Try Computer Co., Ltd
#define UHS_VID_HIRAKAWA_HEWTECH 0x0d71U // Hirakawa Hewtech Corp.
#define UHS_VID_WINMATE_COMMUNICATION 0x0d72U // Winmate Communication, Inc.
#define UHS_VID_HITS_COMMUNICATIONS 0x0d73U // Hit's Communications, Inc.
#define UHS_VID_MFP_KOREA 0x0d76U // MFP Korea, Inc.
#define UHS_VID_POWER_SENTRYNEWPOINT 0x0d77U // Power Sentry/Newpoint
#define UHS_VID_JAPAN_DISTRIBUTOR 0x0d78U // Japan Distributor Corp.
#define UHS_VID_MARX_DATENTECHNIK 0x0d7aU // MARX Datentechnik GmbH
#define UHS_VID_WELLCO_TECHNOLOGY 0x0d7bU // Wellco Technology Co., Ltd
#define UHS_VID_TAIWAN_LINE_TEK_ELECTRONIC 0x0d7cU // Taiwan Line Tek Electronic Co., Ltd
#define UHS_VID_PHISON_ELECTRONICS 0x0d7dU // Phison Electronics Corp.
#define UHS_VID_AMERICAN_COMPUTER_AND_DIGITAL_COMPONENTS 0x0d7eU // American Computer & Digital Components
#define UHS_VID_ESSENTIAL_REALITY 0x0d7fU // Essential Reality LLC
#define UHS_VID_HR_SILVINE_ELECTRONICS 0x0d80U // H.R. Silvine Electronics, Inc.
#define UHS_VID_TECHNOVISION 0x0d81U // TechnoVision
#define UHS_VID_THINK_OUTSIDE 0x0d83U // Think Outside, Inc.
#define UHS_VID_DOLBY_LABORATORIES 0x0d87U // Dolby Laboratories Inc.
#define UHS_VID_OZ_SOFTWARE 0x0d89U // Oz Software
#define UHS_VID_KING_JIM 0x0d8aU // King Jim Co., Ltd
#define UHS_VID_ASCOM_TELECOMMUNICATIONS 0x0d8bU // Ascom Telecommunications, Ltd
#define UHS_VID_C_MEDIA_ELECTRONICS 0x0d8cU // C-Media Electronics, Inc.
#define UHS_VID_PROMOTION_AND_DISPLAY_TECHNOLOGY 0x0d8dU // Promotion & Display Technology, Ltd
#define UHS_VID_GLOBAL_SUN_TECHNOLOGY 0x0d8eU // Global Sun Technology, Inc.
#define UHS_VID_PITNEY_BOWES 0x0d8fU // Pitney Bowes
#define UHS_VID_SURE_FIRE_ELECTRICAL 0x0d90U // Sure-Fire Electrical Corp.
#define UHS_VID_SKANHEX_TECHNOLOGY 0x0d96U // Skanhex Technology, Inc.
#define UHS_VID_SANTA_BARBARA_INSTRUMENT_GROUP 0x0d97U // Santa Barbara Instrument Group
#define UHS_VID_MARS_SEMICONDUCTOR 0x0d98U // Mars Semiconductor Corp.
#define UHS_VID_TRAZER_TECHNOLOGIES 0x0d99U // Trazer Technologies, Inc.
#define UHS_VID_RTX_TELECOM_AS 0x0d9aU // RTX Telecom AS
#define UHS_VID_TAT_SHING_ELECTRICAL 0x0d9bU // Tat Shing Electrical Co.
#define UHS_VID_CHEE_CHEN_HI_TECHNOLOGY 0x0d9cU // Chee Chen Hi-Technology Co., Ltd
#define UHS_VID_SANWA_SUPPLY 0x0d9dU // Sanwa Supply, Inc.
#define UHS_VID_AVAYA 0x0d9eU // Avaya
#define UHS_VID_POWERCOM 0x0d9fU // Powercom Co., Ltd
#define UHS_VID_DANGER_RESEARCH 0x0da0U // Danger Research
#define UHS_VID_SUZHOU_PETERS_PRECISE_INDUSTRIAL 0x0da1U // Suzhou Peter's Precise Industrial Co., Ltd
#define UHS_VID_LAND_INSTRUMENTS_INTERNATIONAL 0x0da2U // Land Instruments International, Ltd
#define UHS_VID_NIPPON_ELECTRO_SENSORY_DEVICES 0x0da3U // Nippon Electro-Sensory Devices Corp.
#define UHS_VID_POLAR_ELECTRO_OY 0x0da4U // Polar Electro Oy
#define UHS_VID_IOGEAR 0x0da7U // IOGear, Inc.
#define UHS_VID_SOFTDSP 0x0da8U // softDSP Co., Ltd
#define UHS_VID_CUBIG_GROUP 0x0dabU // Cubig Group
#define UHS_VID_WESTOVER_SCIENTIFIC 0x0dadU // Westover Scientific
#define UHS_VID_MICRO_STAR_INTERNATIONAL 0x0db0U // Micro Star International
#define UHS_VID_WEN_TE_ELECTRONICS 0x0db1U // Wen Te Electronics Co., Ltd
#define UHS_VID_SHIAN_HWI_PLUG_PARTS_PLASTIC_FACTORY 0x0db2U // Shian Hwi Plug Parts, Plastic Factory
#define UHS_VID_TEKRAM_TECHNOLOGY_1 0x0db3U // Tekram Technology Co., Ltd
#define UHS_VID_CHUNG_FU_CHEN_YEH_ENTERPRISE 0x0db4U // Chung Fu Chen Yeh Enterprise Corp.
#define UHS_VID_ACCESS_IS 0x0db5U // Access IS
#define UHS_VID_ELCON_SYSTEMTECHNIK 0x0db7U // ELCON Systemtechnik
#define UHS_VID_DIGIDESIGN 0x0dbaU // Digidesign
#define UHS_VID_AANDD_MEDICAL 0x0dbcU // A&D Medical
#define UHS_VID_JIUH_SHIUH_PRECISION_INDUSTRY 0x0dbeU // Jiuh Shiuh Precision Industry Co., Ltd
#define UHS_VID_JESS_LINK_INTERNATIONAL 0x0dbfU // Jess-Link International
#define UHS_VID_G7_SOLUTIONS_FORMERLY_GREAT_NOTIONS 0x0dc0U // G7 Solutions (formerly Great Notions)
#define UHS_VID_TAMAGAWA_SEIKI 0x0dc1U // Tamagawa Seiki Co., Ltd
#define UHS_VID_ATHENA_SMARTCARD_SOLUTIONS 0x0dc3U // Athena Smartcard Solutions, Inc.
#define UHS_VID_MACPOWER_PERIPHERALS 0x0dc4U // Macpower Peripherals, Ltd
#define UHS_VID_SDK 0x0dc5U // SDK Co., Ltd
#define UHS_VID_PRECISION_SQUARED_TECHNOLOGY 0x0dc6U // Precision Squared Technology Corp.
#define UHS_VID_FIRST_CABLE_LINE 0x0dc7U // First Cable Line, Inc.
#define UHS_VID_NETWORKFAB 0x0dcdU // NetworkFab Corp.
#define UHS_VID_ACCESS_SOLUTIONS 0x0dd0U // Access Solutions
#define UHS_VID_CONTEK_ELECTRONICS 0x0dd1U // Contek Electronics Co., Ltd
#define UHS_VID_POWER_QUOTIENT_INTERNATIONAL 0x0dd2U // Power Quotient International Co., Ltd
#define UHS_VID_MEDIAQ 0x0dd3U // MediaQ
#define UHS_VID_CUSTOM_ENGINEERING_SPA 0x0dd4U // Custom Engineering SPA
#define UHS_VID_CALIFORNIA_MICRO_DEVICES 0x0dd5U // California Micro Devices
#define UHS_VID_KOCOM 0x0dd7U // Kocom Co., Ltd
#define UHS_VID_NETAC_TECHNOLOGY 0x0dd8U // Netac Technology Co., Ltd
#define UHS_VID_HIGHSPEED_SURFING 0x0dd9U // HighSpeed Surfing
#define UHS_VID_INTEGRATED_CIRCUIT_SOLUTION 0x0ddaU // Integrated Circuit Solution, Inc.
#define UHS_VID_TAMARACK 0x0ddbU // Tamarack, Inc.
#define UHS_VID_DATELINK_TECHNOLOGY 0x0dddU // Datelink Technology Co., Ltd
#define UHS_VID_UBICOM 0x0ddeU // Ubicom, Inc.
#define UHS_VID_BD_CONSUMER_HEALTHCARE 0x0de0U // BD Consumer Healthcare
#define UHS_VID_USBMICRO 0x0de7U // USBmicro
#define UHS_VID_UTECH_ELECTRONIC_DG 0x0deaU // UTECH Electronic (D.G.) Co., Ltd.
#define UHS_VID_NOVASONICS 0x0dedU // Novasonics
#define UHS_VID_LIFETIME_MEMORY_PRODUCTS 0x0deeU // Lifetime Memory Products
#define UHS_VID_FULL_RISE_ELECTRONIC 0x0defU // Full Rise Electronic Co., Ltd
#define UHS_VID_NETANDSYS 0x0df4U // NET&SYS
#define UHS_VID_SITECOM_EUROPE_BV 0x0df6U // Sitecom Europe B.V.
#define UHS_VID_MOBILE_ACTION_TECHNOLOGY 0x0df7U // Mobile Action Technology, Inc.
#define UHS_VID_TOYO_COMMUNICATION_EQUIPMENT 0x0dfaU // Toyo Communication Equipment Co., Ltd
#define UHS_VID_GENERALTOUCH_TECHNOLOGY 0x0dfcU // GeneralTouch Technology Co., Ltd
#define UHS_VID_NIPPON_SYSTEMWARE 0x0e03U // Nippon Systemware Co., Ltd
#define UHS_VID_WINBEST_TECHNOLOGY 0x0e08U // Winbest Technology Co., Ltd
#define UHS_VID_AMIGO_TECHNOLOGY 0x0e0bU // Amigo Technology Inc.
#define UHS_VID_GESYTEC 0x0e0cU // Gesytec
#define UHS_VID_PICOQUANT 0x0e0dU // PicoQuant GmbH
#define UHS_VID_VMWARE 0x0e0fU // VMware, Inc.
#define UHS_VID_JMTEK_1 0x0e16U // JMTek, LLC
#define UHS_VID_WALEX_ELECTRONIC 0x0e17U // Walex Electronic, Ltd
#define UHS_VID_UNISYS_1 0x0e1aU // Unisys
#define UHS_VID_CREWAVE 0x0e1bU // Crewave
#define UHS_VID_PEGASUS_TECHNOLOGIES 0x0e20U // Pegasus Technologies Ltd.
#define UHS_VID_COWON_SYSTEMS 0x0e21U // Cowon Systems, Inc.
#define UHS_VID_SYMBIAN 0x0e22U // Symbian Ltd.
#define UHS_VID_LIOU_YUANE_ENTERPRISE 0x0e23U // Liou Yuane Enterprise Co., Ltd
#define UHS_VID_VINCHIP_SYSTEMS 0x0e25U // VinChip Systems, Inc.
#define UHS_VID_J_PHONE_EAST 0x0e26U // J-Phone East Co., Ltd
#define UHS_VID_HEARTMATH 0x0e30U // HeartMath LLC
#define UHS_VID_MICRO_COMPUTER_CONTROL 0x0e34U // Micro Computer Control Corp.
#define UHS_VID_3PEA_TECHNOLOGIES 0x0e35U // 3Pea Technologies, Inc.
#define UHS_VID_TIEPIE_ENGINEERING 0x0e36U // TiePie engineering
#define UHS_VID_STRATITEC 0x0e38U // Stratitec, Inc.
#define UHS_VID_SMART_MODULAR_TECHNOLOGIES 0x0e39U // Smart Modular Technologies, Inc.
#define UHS_VID_NEOSTAR_TECHNOLOGY 0x0e3aU // Neostar Technology Co., Ltd
#define UHS_VID_MANSELLA 0x0e3bU // Mansella, Ltd
#define UHS_VID_LINE6 0x0e41U // Line6, Inc.
#define UHS_VID_SUN_RISEFUL_TECHNOLOGY 0x0e44U // Sun-Riseful Technology Co., Ltd.
#define UHS_VID_JULIA 0x0e48U // Julia Corp., Ltd
#define UHS_VID_SHENZHEN_BAO_HING_ELECTRIC_WIRE_AND_CABLE_MFR 0x0e4aU // Shenzhen Bao Hing Electric Wire & Cable Mfr. Co.
#define UHS_VID_RADICA_GAMES 0x0e4cU // Radica Games, Ltd
#define UHS_VID_TECHNODATA_INTERWARE 0x0e50U // TechnoData Interware
#define UHS_VID_SPEED_DRAGON_MULTIMEDIA 0x0e55U // Speed Dragon Multimedia, Ltd
#define UHS_VID_KINGSTON_TECHNOLOGY_COMPANY 0x0e56U // Kingston Technology Company, Inc.
#define UHS_VID_ACTIVE 0x0e5aU // Active Co., Ltd
#define UHS_VID_UNION_POWER_INFORMATION_INDUSTRIAL 0x0e5bU // Union Power Information Industrial Co., Ltd
#define UHS_VID_BITLAND_INFORMATION_TECHNOLOGY 0x0e5cU // Bitland Information Technology Co., Ltd
#define UHS_VID_NELTRON_INDUSTRIAL 0x0e5dU // Neltron Industrial Co., Ltd
#define UHS_VID_CONWISE_TECHNOLOGY 0x0e5eU // Conwise Technology Co., Ltd.
#define UHS_VID_HAWKING_TECHNOLOGIES 0x0e66U // Hawking Technologies
#define UHS_VID_FOSSIL 0x0e67U // Fossil, Inc.
#define UHS_VID_MEGAWIN_TECHNOLOGY 0x0e6aU // Megawin Technology Co., Ltd
#define UHS_VID_LOGIC3 0x0e6fU // Logic3
#define UHS_VID_TOKYO_ELECTRONIC_INDUSTRY 0x0e70U // Tokyo Electronic Industry Co., Ltd
#define UHS_VID_HSI_CHIN_ELECTRONICS 0x0e72U // Hsi-Chin Electronics Co., Ltd
#define UHS_VID_TVS_ELECTRONICS 0x0e75U // TVS Electronics, Ltd
#define UHS_VID_ARCHOS 0x0e79U // Archos, Inc.
#define UHS_VID_ON_TECH_INDUSTRY 0x0e7bU // On-Tech Industry Co., Ltd
#define UHS_VID_GMATE 0x0e7eU // Gmate, Inc.
#define UHS_VID_CHING_TAI_ELECTRIC_WIRE_AND_CABLE 0x0e82U // Ching Tai Electric Wire & Cable Co., Ltd
#define UHS_VID_SHIN_AN_WIRE_AND_CABLE 0x0e83U // Shin An Wire & Cable Co.
#define UHS_VID_WELL_FORCE_ELECTRONIC 0x0e8cU // Well Force Electronic Co., Ltd
#define UHS_VID_MEDIATEK_1 0x0e8dU // MediaTek Inc.
#define UHS_VID_GREENASIA 0x0e8fU // GreenAsia Inc.
#define UHS_VID_WIEBETECH 0x0e90U // WiebeTech, LLC
#define UHS_VID_VTECH_ENGINEERING_CANADA 0x0e91U // VTech Engineering Canada, Ltd
#define UHS_VID_CS_GLORY_ENTERPRISE 0x0e92U // C's Glory Enterprise Co., Ltd
#define UHS_VID_EM_TECHNICS 0x0e93U // eM Technics Co., Ltd
#define UHS_VID_FUTURE_TECHNOLOGY 0x0e95U // Future Technology Co., Ltd
#define UHS_VID_APLUX_COMMUNICATIONS 0x0e96U // Aplux Communications, Ltd
#define UHS_VID_FINGERWORKS 0x0e97U // Fingerworks, Inc.
#define UHS_VID_ADVANCED_ANALOGIC_TECHNOLOGIES 0x0e98U // Advanced Analogic Technologies, Inc.
#define UHS_VID_PARALLEL_DICE 0x0e99U // Parallel Dice Co., Ltd
#define UHS_VID_TA_HSING_INDUSTRIES 0x0e9aU // TA HSING Industries, Ltd
#define UHS_VID_ADTEC 0x0e9bU // ADTEC Corp.
#define UHS_VID_STREAMZAP 0x0e9cU // Streamzap, Inc.
#define UHS_VID_TAMURA 0x0e9fU // Tamura Corp.
#define UHS_VID_OURS_TECHNOLOGY 0x0ea0U // Ours Technology, Inc.
#define UHS_VID_NIHON_COMPUTER 0x0ea6U // Nihon Computer Co., Ltd
#define UHS_VID_MSL_ENTERPRISES 0x0ea7U // MSL Enterprises Corp.
#define UHS_VID_CENDYNE 0x0ea8U // CenDyne, Inc.
#define UHS_VID_HUMAX_1 0x0eadU // Humax Co., Ltd
#define UHS_VID_NOVATECH 0x0eb0U // NovaTech
#define UHS_VID_WIS_TECHNOLOGIES 0x0eb1U // WIS Technologies, Inc.
#define UHS_VID_Y_S_ELECTRONIC 0x0eb2U // Y-S Electronic Co., Ltd
#define UHS_VID_SAINT_TECHNOLOGY 0x0eb3U // Saint Technology Corp.
#define UHS_VID_ENDOR_AG 0x0eb7U // Endor AG
#define UHS_VID_METTLER_TOLEDO 0x0eb8U // Mettler Toledo
#define UHS_VID_THERMO_FISHER_SCIENTIFIC 0x0ebbU // Thermo Fisher Scientific
#define UHS_VID_VWEB 0x0ebeU // VWeb Corp.
#define UHS_VID_OMEGA_TECHNOLOGY_OF_TAIWAN 0x0ebfU // Omega Technology of Taiwan, Inc.
#define UHS_VID_LHI_TECHNOLOGY_CHINA 0x0ec0U // LHI Technology (China) Co., Ltd
#define UHS_VID_ABIT_COMPUTER 0x0ec1U // Abit Computer Corp.
#define UHS_VID_SWEETRAY_INDUSTRIAL 0x0ec2U // Sweetray Industrial, Ltd
#define UHS_VID_AXELL 0x0ec3U // Axell Co., Ltd
#define UHS_VID_BALLRACING_DEVELOPMENTS 0x0ec4U // Ballracing Developments, Ltd
#define UHS_VID_GT_INFORMATION_SYSTEM 0x0ec5U // GT Information System Co., Ltd
#define UHS_VID_INNOVISION_MULTIMEDIA 0x0ec6U // InnoVISION Multimedia, Ltd
#define UHS_VID_THETA_LINK 0x0ec7U // Theta Link Corp.
#define UHS_VID_LITE_ON_IT 0x0ecdU // Lite-On IT Corp.
#define UHS_VID_TAISOL_ELECTRONICS 0x0eceU // TaiSol Electronics Co., Ltd
#define UHS_VID_PHOGENIX_IMAGING 0x0ecfU // Phogenix Imaging, LLC
#define UHS_VID_WINMAXGROUP 0x0ed1U // WinMaxGroup
#define UHS_VID_KYOTO_MICRO_COMPUTER 0x0ed2U // Kyoto Micro Computer Co., Ltd
#define UHS_VID_WING_TECH_ENTERPRISE 0x0ed3U // Wing-Tech Enterprise Co., Ltd
#define UHS_VID_FIBERBYTE 0x0ed5U // Fiberbyte
#define UHS_VID_NORIAKE_ITRON 0x0edaU // Noriake Itron Corp.
#define UHS_VID_E_MDT 0x0edfU // e-MDT Co., Ltd
#define UHS_VID_SHIMA_SEIKI_MFG 0x0ee0U // Shima Seiki Mfg., Ltd
#define UHS_VID_SAROTECH 0x0ee1U // Sarotech Co., Ltd
#define UHS_VID_AMI_SEMICONDUCTOR 0x0ee2U // AMI Semiconductor, Inc.
#define UHS_VID_COMTRUE_TECHNOLOGY 0x0ee3U // ComTrue Technology Corp.
#define UHS_VID_SUNRICH_TECHNOLOGY 0x0ee4U // Sunrich Technology, Ltd
#define UHS_VID_DIGITAL_STREAM_TECHNOLOGY 0x0eeeU // Digital Stream Technology, Inc.
#define UHS_VID_D_WAV_SCIENTIFIC 0x0eefU // D-WAV Scientific Co., Ltd
#define UHS_VID_HITACHI_CABLE 0x0ef0U // Hitachi Cable, Ltd
#define UHS_VID_AICHI_MICRO_INTELLIGENT 0x0ef1U // Aichi Micro Intelligent Corp.
#define UHS_VID_IO_MAGIC 0x0ef2U // I/O Magic Corp.
#define UHS_VID_LYNN_PRODUCTS 0x0ef3U // Lynn Products, Inc.
#define UHS_VID_DSI_DATOTECH 0x0ef4U // DSI Datotech
#define UHS_VID_POINTCHIPS 0x0ef5U // PointChips
#define UHS_VID_YIELD_MICROELECTRONICS 0x0ef6U // Yield Microelectronics Corp.
#define UHS_VID_SM_TECH_CO_LTD_TULIP 0x0ef7U // SM Tech Co., Ltd (Tulip)
#define UHS_VID_OASIS_SEMICONDUCTOR 0x0efdU // Oasis Semiconductor
#define UHS_VID_WEM_TECHNOLOGY 0x0efeU // Wem Technology, Inc.
#define UHS_VID_UNITEK_UPS_SYSTEMS 0x0f03U // Unitek UPS Systems
#define UHS_VID_VISUAL_FRONTIER_ENTERPRISE 0x0f06U // Visual Frontier Enterprise Co., Ltd
#define UHS_VID_CSL_WIRE_AND_PLUG_SHEN_ZHEN 0x0f08U // CSL Wire & Plug (Shen Zhen) Co.
#define UHS_VID_CAS 0x0f0cU // CAS Corp.
#define UHS_VID_HORI 0x0f0dU // Hori Co., Ltd
#define UHS_VID_ENERGY_FULL 0x0f0eU // Energy Full Corp.
#define UHS_VID_LD_DIDACTIC 0x0f11U // LD Didactic GmbH
#define UHS_VID_MARS_ENGINEERING 0x0f12U // Mars Engineering Corp.
#define UHS_VID_ACETEK_TECHNOLOGY 0x0f13U // Acetek Technology Co., Ltd
#define UHS_VID_INGENICO_1 0x0f14U // Ingenico
#define UHS_VID_FINGER_LAKES_INSTRUMENTATION 0x0f18U // Finger Lakes Instrumentation
#define UHS_VID_ORACOM 0x0f19U // Oracom Co., Ltd
#define UHS_VID_ONSET_COMPUTER 0x0f1bU // Onset Computer Corp.
#define UHS_VID_FUNAI_ELECTRIC 0x0f1cU // Funai Electric Co., Ltd
#define UHS_VID_IWILL 0x0f1dU // Iwill Corp.
#define UHS_VID_IOI_TECHNOLOGY 0x0f21U // IOI Technology Corp.
#define UHS_VID_SENIOR_INDUSTRIES 0x0f22U // Senior Industries, Inc.
#define UHS_VID_LEADER_TECH_MANUFACTURER 0x0f23U // Leader Tech Manufacturer Co., Ltd
#define UHS_VID_FLEX_P_INDUSTRIES_SND_BHD 0x0f24U // Flex-P Industries, Snd., Bhd.
#define UHS_VID_VIPOWER 0x0f2dU // ViPower, Inc.
#define UHS_VID_GENIALITY_MAPLE_TECHNOLOGY 0x0f2eU // Geniality Maple Technology Co., Ltd
#define UHS_VID_PRIVA_DESIGN_SERVICES 0x0f2fU // Priva Design Services
#define UHS_VID_JESS_TECHNOLOGY 0x0f30U // Jess Technology Co., Ltd
#define UHS_VID_CHRYSALIS_DEVELOPMENT 0x0f31U // Chrysalis Development
#define UHS_VID_YFC_BONEAGLE_ELECTRIC 0x0f32U // YFC-BonEagle Electric Co., Ltd
#define UHS_VID_KOKUYO 0x0f37U // Kokuyo Co., Ltd
#define UHS_VID_NIEN_YI_INDUSTRIAL 0x0f38U // Nien-Yi Industrial Corp.
#define UHS_VID_TG3_ELECTRONICS_1 0x0f39U // TG3 Electronics
#define UHS_VID_AIRPRIME_INCORPORATED 0x0f3dU // Airprime, Incorporated
#define UHS_VID_RDC_SEMICONDUCTOR 0x0f41U // RDC Semiconductor Co., Ltd
#define UHS_VID_NITAL_CONSULTING_SERVICES 0x0f42U // Nital Consulting Services, Inc.
#define UHS_VID_POLHEMUS 0x0f44U // Polhemus
#define UHS_VID_ST_JOHN_TECHNOLOGY 0x0f4bU // St. John Technology Co., Ltd
#define UHS_VID_WORLDWIDE_CABLE_OPTO 0x0f4cU // WorldWide Cable Opto Corp.
#define UHS_VID_MICROTUNE 0x0f4dU // Microtune, Inc.
#define UHS_VID_FREEDOM_SCIENTIFIC 0x0f4eU // Freedom Scientific
#define UHS_VID_WING_KEY_ELECTRICAL 0x0f52U // Wing Key Electrical Co., Ltd
#define UHS_VID_DONGGUAN_WHITE_HORSE_CABLE_FACTORY 0x0f53U // Dongguan White Horse Cable Factory, Ltd
#define UHS_VID_KAWAI_MUSICAL_INSTRUMENTS_MFG 0x0f54U // Kawai Musical Instruments Mfg. Co., Ltd
#define UHS_VID_AMBICOM 0x0f55U // AmbiCom, Inc.
#define UHS_VID_PRAIRIECOMM 0x0f5cU // Prairiecomm, Inc.
#define UHS_VID_NEWAGE_INTERNATIONAL 0x0f5dU // NewAge International, LLC
#define UHS_VID_KEY_TECHNOLOGY 0x0f5fU // Key Technology Corp.
#define UHS_VID_NTK 0x0f60U // NTK, Ltd
#define UHS_VID_VARIAN 0x0f61U // Varian, Inc.
#define UHS_VID_ACROX_TECHNOLOGIES 0x0f62U // Acrox Technologies Co., Ltd
#define UHS_VID_LEAPFROG_ENTERPRISES 0x0f63U // LeapFrog Enterprises
#define UHS_VID_KOBE_STEEL 0x0f68U // Kobe Steel, Ltd
#define UHS_VID_DIONEX 0x0f69U // Dionex Corp.
#define UHS_VID_VIBREN_TECHNOLOGIES 0x0f6aU // Vibren Technologies, Inc.
#define UHS_VID_INTELLIGENT_SYSTEMS 0x0f6eU // INTELLIGENT SYSTEMS
#define UHS_VID_DFI_1 0x0f73U // DFI
#define UHS_VID_GUNTERMANN_AND_DRUNCK 0x0f78U // Guntermann & Drunck GmbH
#define UHS_VID_DQ_TECHNOLOGY 0x0f7cU // DQ Technology, Inc.
#define UHS_VID_NETBOTZ 0x0f7dU // NetBotz, Inc.
#define UHS_VID_FLUKE 0x0f7eU // Fluke Corp.
#define UHS_VID_VTECH_HOLDINGS 0x0f88U // VTech Holdings, Ltd
#define UHS_VID_YAZAKI 0x0f8bU // Yazaki Corp.
#define UHS_VID_YOUNG_GENERATION_INTERNATIONAL 0x0f8cU // Young Generation International Corp.
#define UHS_VID_UNIWILL_COMPUTER 0x0f8dU // Uniwill Computer Corp.
#define UHS_VID_KINGNET_TECHNOLOGY 0x0f8eU // Kingnet Technology Co., Ltd
#define UHS_VID_SOMA_NETWORKS 0x0f8fU // Soma Networks
#define UHS_VID_CVILUX 0x0f97U // CviLux Corp.
#define UHS_VID_CYBERBANK 0x0f98U // CyberBank Corp.
#define UHS_VID_HYUN_WON 0x0f9cU // Hyun Won, Inc.
#define UHS_VID_LUCENT_TECHNOLOGIES_1 0x0f9eU // Lucent Technologies
#define UHS_VID_STARCONN_ELECTRONIC 0x0fa3U // Starconn Electronic Co., Ltd
#define UHS_VID_ATL_TECHNOLOGY 0x0fa4U // ATL Technology
#define UHS_VID_SOTEC 0x0fa5U // Sotec Co., Ltd
#define UHS_VID_EPOX_COMPUTER 0x0fa7U // Epox Computer Co., Ltd
#define UHS_VID_LOGIC_CONTROLS 0x0fa8U // Logic Controls, Inc.
#define UHS_VID_WINPOINT_ELECTRONIC 0x0fafU // Winpoint Electronic Corp.
#define UHS_VID_HAURTIAN_WIRE_AND_CABLE 0x0fb0U // Haurtian Wire & Cable Co., Ltd
#define UHS_VID_INCLOSE_DESIGN 0x0fb1U // Inclose Design, Inc.
#define UHS_VID_JUAN_CHERN_INDUSTRIAL 0x0fb2U // Juan-Chern Industrial Co., Ltd
#define UHS_VID_HEBER 0x0fb6U // Heber Ltd
#define UHS_VID_WISTRON 0x0fb8U // Wistron Corp.
#define UHS_VID_AACOM 0x0fb9U // AACom Corp.
#define UHS_VID_SAN_SHING_ELECTRONICS 0x0fbaU // San Shing Electronics Co., Ltd
#define UHS_VID_BITWISE_SYSTEMS 0x0fbbU // Bitwise Systems, Inc.
#define UHS_VID_MITAC_INTERNATINAL 0x0fc1U // Mitac Internatinal Corp.
#define UHS_VID_PLUG_AND_JACK_INDUSTRIAL 0x0fc2U // Plug and Jack Industrial, Inc.
#define UHS_VID_DELCOM_ENGINEERING 0x0fc5U // Delcom Engineering
#define UHS_VID_DATAPLUS_SUPPLIES 0x0fc6U // Dataplus Supplies, Inc.
#define UHS_VID_RESEARCH_IN_MOTION 0x0fcaU // Research In Motion, Ltd.
#define UHS_VID_SONY_ERICSSON_MOBILE_COMMUNICATIONS 0x0fceU // Sony Ericsson Mobile Communications AB
#define UHS_VID_DYNASTREAM_INNOVATIONS 0x0fcfU // Dynastream Innovations, Inc.
#define UHS_VID_TULIP_COMPUTERS_BV 0x0fd0U // Tulip Computers B.V.
#define UHS_VID_GIANT_ELECTRONICS 0x0fd1U // Giant Electronics Ltd.
#define UHS_VID_SEAC_BANCHE 0x0fd2U // Seac Banche
#define UHS_VID_TENOVIS_GMBH_AND_CO_KG 0x0fd4U // Tenovis GmbH & Co., KG
#define UHS_VID_DIRECT_ACCESS_TECHNOLOGY 0x0fd5U // Direct Access Technology, Inc.
#define UHS_VID_ELGATO_SYSTEMS 0x0fd9U // Elgato Systems GmbH
#define UHS_VID_QUANTEC_NETWORKS 0x0fdaU // Quantec Networks GmbH
#define UHS_VID_MICRO_PLUS 0x0fdcU // Micro Plus
#define UHS_VID_OREGON_SCIENTIFIC 0x0fdeU // Oregon Scientific
#define UHS_VID_OSTERHOUT_DESIGN_GROUP 0x0fe0U // Osterhout Design Group
#define UHS_VID_IN_TECH_ELECTRONICS 0x0fe4U // IN-Tech Electronics, Ltd
#define UHS_VID_GREENCONN_USA 0x0fe5U // Greenconn (U.S.A.), Inc.
#define UHS_VID_KONTRON_INDUSTRIAL_COMPUTER_SOURCE_ICS_ADVENT 0x0fe6U // Kontron (Industrial Computer Source / ICS Advent)
#define UHS_VID_DVICO 0x0fe9U // DVICO
#define UHS_VID_UNITED_COMPUTER_ACCESSORIES 0x0feaU // United Computer Accessories
#define UHS_VID_CRS_ELECTRONIC 0x0febU // CRS Electronic Co., Ltd
#define UHS_VID_UMC_ELECTRONICS 0x0fecU // UMC Electronics Co., Ltd
#define UHS_VID_ACCESS 0x0fedU // Access Co., Ltd
#define UHS_VID_XSIDO 0x0feeU // Xsido Corp.
#define UHS_VID_MJ_RESEARCH 0x0fefU // MJ Research, Inc.
#define UHS_VID_CORE_VALLEY 0x0ff6U // Core Valley Co., Ltd
#define UHS_VID_CHI_SHING_COMPUTER_ACCESSORIES 0x0ff7U // CHI SHING Computer Accessories Co., Ltd
#define UHS_VID_CLAVIA_DMI 0x0ffcU // Clavia DMI AB
#define UHS_VID_EARLYSENSE 0x0ffdU // EarlySense
#define UHS_VID_AOPEN 0x0fffU // Aopen, Inc.
#define UHS_VID_SPEED_TECH 0x1000U // Speed Tech Corp.
#define UHS_VID_RITRONICS_COMPONENTS_S_PTE 0x1001U // Ritronics Components (S) Pte., Ltd
#define UHS_VID_SIGMA 0x1003U // Sigma Corp.
#define UHS_VID_LG_ELECTRONICS 0x1004U // LG Electronics, Inc.
#define UHS_VID_APACER_TECHNOLOGY 0x1005U // Apacer Technology, Inc.
#define UHS_VID_IRIVER 0x1006U // iRiver, Ltd.
#define UHS_VID_EMUZED 0x1009U // Emuzed, Inc.
#define UHS_VID_AV_CHASEWAY 0x100aU // AV Chaseway, Ltd
#define UHS_VID_CHOU_CHIN_INDUSTRIAL 0x100bU // Chou Chin Industrial Co., Ltd
#define UHS_VID_NETOPIA 0x100dU // Netopia, Inc.
#define UHS_VID_FUKUDA_DENSHI 0x1010U // Fukuda Denshi Co., Ltd
#define UHS_VID_MOBILE_MEDIA_TECH 0x1011U // Mobile Media Tech.
#define UHS_VID_SDKM_FIBRES_WIRES_AND_CABLES_BERHAD 0x1012U // SDKM Fibres, Wires & Cables Berhad
#define UHS_VID_TST_TOUCHLESS_SENSOR_TECHNOLOGY_AG 0x1013U // TST-Touchless Sensor Technology AG
#define UHS_VID_DENSITRON_TECHNOLOGIES_PLC 0x1014U // Densitron Technologies PLC
#define UHS_VID_SOFTRONICS_PTY 0x1015U // Softronics Pty., Ltd
#define UHS_VID_XIAMEN_HUNGS_ENTERPRISE 0x1016U // Xiamen Hung's Enterprise Co., Ltd
#define UHS_VID_SPEEDY_INDUSTRIAL_SUPPLIES_PTE 0x1017U // Speedy Industrial Supplies, Pte., Ltd
#define UHS_VID_ELITEGROUP_COMPUTER_SYSTEMS_ECS 0x1019U // Elitegroup Computer Systems (ECS)
#define UHS_VID_LABTEC_1 0x1020U // Labtec
#define UHS_VID_SHINKO_SHOJI 0x1022U // Shinko Shoji Co., Ltd
#define UHS_VID_HYPER_PALTEK 0x1025U // Hyper-Paltek
#define UHS_VID_NEWLY 0x1026U // Newly Corp.
#define UHS_VID_TIME_DOMAIN 0x1027U // Time Domain
#define UHS_VID_INOVYS 0x1028U // Inovys Corp.
#define UHS_VID_ATLANTIC_COAST_TELESYS 0x1029U // Atlantic Coast Telesys
#define UHS_VID_RAMOS_TECHNOLOGY 0x102aU // Ramos Technology Co., Ltd
#define UHS_VID_INFOTRONIC_AMERICA 0x102bU // Infotronic America, Inc.
#define UHS_VID_ETOMS_ELECTRONICS 0x102cU // Etoms Electronics Corp.
#define UHS_VID_WINIC 0x102dU // Winic Corp.
#define UHS_VID_COMAX_TECHNOLOGY 0x1031U // Comax Technology, Inc.
#define UHS_VID_C_ONE_TECHNOLOGY 0x1032U // C-One Technology Corp.
#define UHS_VID_NUCAM 0x1033U // Nucam Corp.
#define UHS_VID_STEELSERIES_APS 0x1038U // SteelSeries ApS
#define UHS_VID_DEVOLO_AG 0x1039U // devolo AG
#define UHS_VID_PSA 0x103aU // PSA
#define UHS_VID_STANTON 0x103dU // Stanton
#define UHS_VID_ICREATE_TECHNOLOGIES 0x1043U // iCreate Technologies Corp.
#define UHS_VID_CHU_YUEN_ENTERPRISE 0x1044U // Chu Yuen Enterprise Co., Ltd
#define UHS_VID_WINBOND_ELECTRONICS_CORP_HEX_ 0x1046U // Winbond Electronics Corp. [hex]
#define UHS_VID_TARGUS_GROUP_INTERNATIONAL 0x1048U // Targus Group International
#define UHS_VID_MYLEX_BUSLOGIC 0x104bU // Mylex / Buslogic
#define UHS_VID_AMCO_TEC_INTERNATIONAL 0x104cU // AMCO TEC International, Inc.
#define UHS_VID_NEWPORT_CORPORATION 0x104dU // Newport Corporation
#define UHS_VID_WB_ELECTRONICS 0x104fU // WB Electronics
#define UHS_VID_YUBICOCOM 0x1050U // Yubico.com
#define UHS_VID_IMMANUEL_ELECTRONICS 0x1053U // Immanuel Electronics Co., Ltd
#define UHS_VID_BMS_INTERNATIONAL_BEHEER_NV 0x1054U // BMS International Beheer N.V.
#define UHS_VID_COMPLEX_MICRO_INTERCONNECTION 0x1055U // Complex Micro Interconnection Co., Ltd
#define UHS_VID_HSIN_CHEN_ENT 0x1056U // Hsin Chen Ent Co., Ltd
#define UHS_VID_ON_SEMICONDUCTOR 0x1057U // ON Semiconductor
#define UHS_VID_WESTERN_DIGITAL_TECHNOLOGIES 0x1058U // Western Digital Technologies, Inc.
#define UHS_VID_GIESECKE_AND_DEVRIENT 0x1059U // Giesecke & Devrient GmbH
#define UHS_VID_FOXCONN_INTERNATIONAL 0x105bU // Foxconn International, Inc.
#define UHS_VID_HONG_JI_ELECTRIC_WIRE_AND_CABLE_DONGGUAN 0x105cU // Hong Ji Electric Wire & Cable (Dongguan) Co., Ltd
#define UHS_VID_DELKIN_DEVICES 0x105dU // Delkin Devices, Inc.
#define UHS_VID_VALENCE_SEMICONDUCTOR_DESIGN 0x105eU // Valence Semiconductor Design, Ltd
#define UHS_VID_CHIN_SHONG_ENTERPRISE 0x105fU // Chin Shong Enterprise Co., Ltd
#define UHS_VID_EASTHOME_INDUSTRIAL 0x1060U // Easthome Industrial Co., Ltd
#define UHS_VID_MOTOROLA_ELECTRONICS_TAIWAN_LTD_HEX_ 0x1063U // Motorola Electronics Taiwan, Ltd [hex]
#define UHS_VID_CCYU_TECHNOLOGY 0x1065U // CCYU Technology
#define UHS_VID_LOYAL_LEGEND 0x106aU // Loyal Legend, Ltd
#define UHS_VID_CURITEL_COMMUNICATIONS 0x106cU // Curitel Communications, Inc.
#define UHS_VID_SAN_CHIEH_MANUFACTURING 0x106dU // San Chieh Manufacturing, Ltd
#define UHS_VID_CONECTL 0x106eU // ConectL
#define UHS_VID_MONEY_CONTROLS 0x106fU // Money Controls
#define UHS_VID_GCT_SEMICONDUCTOR 0x1076U // GCT Semiconductor, Inc.
#define UHS_VID_GATEWAY_1 0x107bU // Gateway, Inc.
#define UHS_VID_ARLEC_AUSTRALIA 0x107dU // Arlec Australia, Ltd
#define UHS_VID_MIDORIYA_ELECTRIC 0x107eU // Midoriya Electric Co., Ltd
#define UHS_VID_KIDZMOUSE 0x107fU // KidzMouse, Inc.
#define UHS_VID_SHIN_ETSUKAKEN 0x1082U // Shin-Etsukaken Co., Ltd
#define UHS_VID_CANON_ELECTRONICS 0x1083U // Canon Electronics, Inc.
#define UHS_VID_PANTECH 0x1084U // Pantech Co., Ltd
#define UHS_VID_CHLORIDE_POWER_PROTECTION 0x108aU // Chloride Power Protection
#define UHS_VID_GRAND_TEK_TECHNOLOGY 0x108bU // Grand-tek Technology Co., Ltd
#define UHS_VID_ROBERT_BOSCH 0x108cU // Robert Bosch GmbH
#define UHS_VID_LOTES 0x108eU // Lotes Co., Ltd.
#define UHS_VID_SURFACE_OPTICS 0x1099U // Surface Optics Corp.
#define UHS_VID_DATASOFT_SYSTEMS 0x109aU // DATASOFT Systems GmbH
#define UHS_VID_HISENSE 0x109bU // Hisense
#define UHS_VID_ESOL 0x109fU // eSOL Co., Ltd
#define UHS_VID_HIROTECH 0x10a0U // Hirotech, Inc.
#define UHS_VID_MITSUBISHI_MATERIALS 0x10a3U // Mitsubishi Materials Corp.
#define UHS_VID_SK_TELETECH 0x10a9U // SK Teletech Co., Ltd
#define UHS_VID_CABLES_TO_GO 0x10aaU // Cables To Go
#define UHS_VID_USI 0x10abU // USI Co., Ltd
#define UHS_VID_HONEYWELL 0x10acU // Honeywell, Inc.
#define UHS_VID_PRINCETON_TECHNOLOGY 0x10aeU // Princeton Technology Corp.
#define UHS_VID_LIEBERT 0x10afU // Liebert Corp.
#define UHS_VID_COMODO_PLX_UNKNOWN 0x10b5U // Comodo (PLX?)
#define UHS_VID_DIBCOM 0x10b8U // DiBcom
#define UHS_VID_TM_TECHNOLOGY 0x10bbU // TM Technology, Inc.
#define UHS_VID_DINGING_TECHNOLOGY 0x10bcU // Dinging Technology Co., Ltd
#define UHS_VID_TMT_TECHNOLOGY 0x10bdU // TMT Technology, Inc.
#define UHS_VID_SMARTHOME 0x10bfU // SmartHome
#define UHS_VID_UNIVERSAL_LASER_SYSTEMS 0x10c3U // Universal Laser Systems, Inc.
#define UHS_VID_CYGNAL_INTEGRATED_PRODUCTS 0x10c4U // Cygnal Integrated Products, Inc.
#define UHS_VID_SANEI_ELECTRIC 0x10c5U // Sanei Electric, Inc.
#define UHS_VID_INTEC 0x10c6U // Intec, Inc.
#define UHS_VID_ERATECH 0x10cbU // Eratech
#define UHS_VID_GBM_CONNECTOR 0x10ccU // GBM Connector Co., Ltd
#define UHS_VID_KYCON 0x10cdU // Kycon, Inc.
#define UHS_VID_SILICON_LABS 0x10ceU // Silicon Labs
#define UHS_VID_VELLEMAN_COMPONENTS 0x10cfU // Velleman Components, Inc.
#define UHS_VID_HOTTINGER_BALDWIN_MEASUREMENT 0x10d1U // Hottinger Baldwin Measurement
#define UHS_VID_RAYCOMPOSER__R_ADAMS 0x10d2U // RayComposer - R. Adams
#define UHS_VID_MAN_BOON_MANUFACTORY 0x10d4U // Man Boon Manufactory, Ltd
#define UHS_VID_UNI_CLASS_TECHNOLOGY 0x10d5U // Uni Class Technology Co., Ltd
#define UHS_VID_ACTIONS_SEMICONDUCTOR 0x10d6U // Actions Semiconductor Co., Ltd
#define UHS_VID_AUTHENEX 0x10deU // Authenex, Inc.
#define UHS_VID_IN_WIN_DEVELOPMENT 0x10dfU // In-Win Development, Inc.
#define UHS_VID_POST_OP_VIDEO 0x10e0U // Post-Op Video, Inc.
#define UHS_VID_CABLEPLUS 0x10e1U // CablePlus, Ltd
#define UHS_VID_NADA_ELECTRONICS 0x10e2U // Nada Electronics, Ltd
#define UHS_VID_VAST_TECHNOLOGIES 0x10ecU // Vast Technologies, Inc.
#define UHS_VID_NEXIO 0x10f0U // Nexio Co., Ltd
#define UHS_VID_IMPORTEK 0x10f1U // Importek
#define UHS_VID_TURTLE_BEACH 0x10f5U // Turtle Beach
#define UHS_VID_PICTOS_TECHNOLOGIES 0x10fbU // Pictos Technologies, Inc.
#define UHS_VID_ANUBIS_ELECTRONICS 0x10fdU // Anubis Electronics, Ltd
#define UHS_VID_THRANE_AND_THRANE 0x10feU // Thrane & Thrane
#define UHS_VID_VIRTOUCH 0x1100U // VirTouch, Ltd
#define UHS_VID_EASYPASS_INDUSTRIAL 0x1101U // EasyPass Industrial Co., Ltd
#define UHS_VID_BRIGHTCOM_TECHNOLOGIES 0x1108U // Brightcom Technologies, Ltd
#define UHS_VID_MOXA_TECHNOLOGIES 0x110aU // Moxa Technologies Co., Ltd.
#define UHS_VID_ANALOG_DEVICES_CANADA_LTD_ALLIED_TELESYN 0x1110U // Analog Devices Canada, Ltd (Allied Telesyn)
#define UHS_VID_PANDORA_INTERNATIONAL 0x1111U // Pandora International Ltd.
#define UHS_VID_YM_ELECTRIC 0x1112U // YM ELECTRIC CO., Ltd
#define UHS_VID_MEDION_AG 0x1113U // Medion AG
#define UHS_VID_VSO_ELECTRIC 0x111eU // VSO Electric Co., Ltd
#define UHS_VID_REDRAT 0x112aU // RedRat
#define UHS_VID_MASTER_HILL_ELECTRIC_WIRE_AND_CABLE 0x112eU // Master Hill Electric Wire and Cable Co., Ltd
#define UHS_VID_CELLON_INTERNATIONAL 0x112fU // Cellon International, Inc.
#define UHS_VID_TENX_TECHNOLOGY 0x1130U // Tenx Technology, Inc.
#define UHS_VID_INTEGRATED_SYSTEM_SOLUTION 0x1131U // Integrated System Solution Corp.
#define UHS_VID_TOSHIBA_CORP_DIGITAL_MEDIA_EQUIPMENT_HEX_ 0x1132U // Toshiba Corp., Digital Media Equipment [hex]
#define UHS_VID_CTS_ELECTRONINCS 0x1136U // CTS Electronincs
#define UHS_VID_ARIN_TECH 0x113cU // Arin Tech Co., Ltd
#define UHS_VID_MAPOWER_ELECTRONICS 0x113dU // Mapower Electronics Co., Ltd
#define UHS_VID_V_ONE_MULTIMEDIA_PTE 0x1141U // V One Multimedia, Pte., Ltd
#define UHS_VID_CYBERSCAN_TECHNOLOGIES 0x1142U // CyberScan Technologies, Inc.
#define UHS_VID_JAPAN_RADIO_COMPANY 0x1145U // Japan Radio Company
#define UHS_VID_SHIMANE_SANYO_ELECTRIC 0x1146U // Shimane SANYO Electric Co., Ltd.
#define UHS_VID_EVER_GREAT_ELECTRIC_WIRE_AND_CABLE 0x1147U // Ever Great Electric Wire and Cable Co., Ltd
#define UHS_VID_SPHAIRON_ACCESS_SYSTEMS 0x114bU // Sphairon Access Systems GmbH
#define UHS_VID_TINIUS_OLSEN_TESTING_MACHINE 0x114cU // Tinius Olsen Testing Machine Co., Inc.
#define UHS_VID_ALPHA_IMAGING_TECHNOLOGY 0x114dU // Alpha Imaging Technology Corp.
#define UHS_VID_WAVECOM 0x114fU // Wavecom
#define UHS_VID_SALIX_TECHNOLOGY 0x115bU // Salix Technology Co., Ltd.
#define UHS_VID_SECUGEN 0x1162U // Secugen Corp.
#define UHS_VID_DELORME_PUBLISHING 0x1163U // DeLorme Publishing, Inc.
#define UHS_VID_YUAN_HIGH_TECH_DEVELOPMENT 0x1164U // YUAN High-Tech Development Co., Ltd
#define UHS_VID_TELSON_ELECTRONICS 0x1165U // Telson Electronics Co., Ltd
#define UHS_VID_BANTAM_INTERACTIVE_TECHNOLOGIES 0x1166U // Bantam Interactive Technologies
#define UHS_VID_SALIENT_SYSTEMS 0x1167U // Salient Systems Corp.
#define UHS_VID_BIZCONN_INTERNATIONAL 0x1168U // BizConn International Corp.
#define UHS_VID_GIGASTORAGE 0x116eU // Gigastorage Corp.
#define UHS_VID_SILICON_10_TECHNOLOGY 0x116fU // Silicon 10 Technology Corp.
#define UHS_VID_SHENGYIH_STEEL_MOLD 0x1175U // Shengyih Steel Mold Co., Ltd
#define UHS_VID_SANTA_ELECTRONIC 0x117dU // Santa Electronic, Inc.
#define UHS_VID_JNC 0x117eU // JNC, Inc.
#define UHS_VID_VENTURE 0x1182U // Venture Corp., Ltd
#define UHS_VID_COMPAQ_COMPUTER_CORP_HEX_DIGITAL_DREAM_UNKNOWN 0x1183U // Compaq Computer Corp. [hex] (Digital Dream ?)
#define UHS_VID_KYOCERA_ELCO 0x1184U // Kyocera Elco Corp.
#define UHS_VID_BLOOMBERG_LP 0x1188U // Bloomberg L.P.
#define UHS_VID_ACER_COMMUNICATIONS_AND_MULTIMEDIA 0x1189U // Acer Communications & Multimedia
#define UHS_VID_YOU_YANG_TECHNOLOGY 0x118fU // You Yang Technology Co., Ltd
#define UHS_VID_TRIPACE 0x1190U // Tripace
#define UHS_VID_LOYALTY_FOUNDER_ENTERPRISE 0x1191U // Loyalty Founder Enterprise Co., Ltd
#define UHS_VID_YANKEE_ROBOTICS 0x1196U // Yankee Robotics, LLC
#define UHS_VID_TECHNOIMAGIA 0x1197U // Technoimagia Co., Ltd
#define UHS_VID_STARSHINE_TECHNOLOGY 0x1198U // StarShine Technology Corp.
#define UHS_VID_SIERRA_WIRELESS 0x1199U // Sierra Wireless, Inc.
#define UHS_VID_ZHAN_QI_TECHNOLOGY 0x119aU // ZHAN QI Technology Co., Ltd
#define UHS_VID_RUWIDO_AUSTRIA 0x119bU // ruwido austria GmbH
#define UHS_VID_CHIPCON_AS 0x11a0U // Chipcon AS
#define UHS_VID_TECHNOVAS 0x11a3U // Technovas Co., Ltd
#define UHS_VID_GLOBALMEDIA_GROUP 0x11aaU // GlobalMedia Group, LLC
#define UHS_VID_EXITO_ELECTRONICS 0x11abU // Exito Electronics Co., Ltd
#define UHS_VID_NIKE 0x11acU // Nike
#define UHS_VID_ATECH_FLASH_TECHNOLOGY 0x11b0U // ATECH FLASH TECHNOLOGY
#define UHS_VID_RANDD_INTERNATIONAL_NV 0x11beU // R&D International NV
#define UHS_VID_INMAX 0x11c5U // Inmax
#define UHS_VID_VERIFONE 0x11caU // VeriFone Inc
#define UHS_VID_TOPFIELD 0x11dbU // Topfield Co., Ltd.
#define UHS_VID_KI_TECHNOLOGY 0x11e6U // K.I. Technology Co. Ltd.
#define UHS_VID_SIEMENS_AG_1 0x11f5U // Siemens AG
#define UHS_VID_PROLIFIC 0x11f6U // Prolific
#define UHS_VID_ALCATEL_UNKNOWN 0x11f7U // Alcatel (?)
#define UHS_VID_TSC_AUTO_ID_TECHNOLOGY 0x1203U // TSC Auto ID Technology Co., Ltd
#define UHS_VID_INTERBIOMETRICS 0x1209U // InterBiometrics
#define UHS_VID_HUDSON_SOFT 0x120eU // Hudson Soft Co., Ltd
#define UHS_VID_MAGELLAN 0x120fU // Magellan
#define UHS_VID_DIGITECH 0x1210U // DigiTech
#define UHS_VID_JUNGSOFT 0x121eU // Jungsoft Co., Ltd
#define UHS_VID_UNKNOWN_MANUFACTURER_1 0x1221U // Unknown manufacturer
#define UHS_VID_SKYCABLE_ENTERPRISE 0x1223U // SKYCABLE ENTERPRISE. CO., LTD.
#define UHS_VID_DATAPAQ_LIMITED 0x1228U // Datapaq Limited
#define UHS_VID_CHIPIDEA_MICROELECTRONICA 0x1230U // Chipidea-Microelectronica, S.A.
#define UHS_VID_DENVER_ELECTRONICS 0x1233U // Denver Electronics
#define UHS_VID_BRAIN_ACTUATED_TECHNOLOGIES 0x1234U // Brain Actuated Technologies
#define UHS_VID_FOCUSRITE_NOVATION 0x1235U // Focusrite-Novation
#define UHS_VID_BELKIN 0x1241U // Belkin
#define UHS_VID_AIRVAST 0x124aU // AirVast
#define UHS_VID_NYKO_HONEY_BEE 0x124bU // Nyko (Honey Bee)
#define UHS_VID_MXI__MEMORY_EXPERTS_INTERNATIONAL 0x124cU // MXI - Memory Experts International, Inc.
#define UHS_VID_APOGEE 0x125cU // Apogee Inc.
#define UHS_VID_A_DATA_TECHNOLOGY 0x125fU // A-DATA Technology Co., Ltd.
#define UHS_VID_STANDARD_MICROSYSTEMS_3 0x1260U // Standard Microsystems Corp.
#define UHS_VID_COVIDIEN_ENERGY_BASED_DEVICES 0x1264U // Covidien Energy-based Devices
#define UHS_VID_PIRELLI_BROADBAND_SOLUTIONS 0x1266U // Pirelli Broadband Solutions
#define UHS_VID_LOGIC3_SPECTRAVIDEO_PLC 0x1267U // Logic3 / SpectraVideo plc
#define UHS_VID_ARISTOCRAT_TECHNOLOGIES 0x126cU // Aristocrat Technologies
#define UHS_VID_BEL_STEWART 0x126dU // Bel Stewart
#define UHS_VID_STROBE_DATA 0x126eU // Strobe Data, Inc.
#define UHS_VID_TWINMOS 0x126fU // TwinMOS
#define UHS_VID_ENSONIQ 0x1274U // Ensoniq
#define UHS_VID_XAXERO_MARINE_SOFTWARE_ENGINEERING 0x1275U // Xaxero Marine Software Engineering, Ltd.
#define UHS_VID_STARLIGHT_XPRESS 0x1278U // Starlight Xpress
#define UHS_VID_ZEBRIS_MEDICAL 0x1283U // zebris Medical GmbH
#define UHS_VID_MARVELL_SEMICONDUCTOR 0x1286U // Marvell Semiconductor, Inc.
#define UHS_VID_QUALCOMM_FLARION_TECHNOLOGIES_INC_LEADTEK_RESEARCH 0x1291U // Qualcomm Flarion Technologies, Inc. / Leadtek Research, Inc.
#define UHS_VID_INNOMEDIA_1 0x1292U // Innomedia
#define UHS_VID_BELKIN_COMPONENTS_HEX_ 0x1293U // Belkin Components [hex]
#define UHS_VID_RISO_KAGAKU 0x1294U // RISO KAGAKU CORP.
#define UHS_VID_CYBERTAN_TECHNOLOGY 0x129bU // CyberTAN Technology
#define UHS_VID_TRENDCHIP_TECHNOLOGIES 0x12a7U // Trendchip Technologies Corp.
#define UHS_VID_HONEY_BEE_ELECTRONIC_INTERNATIONAL 0x12abU // Honey Bee Electronic International Ltd.
#define UHS_VID_ZHEJIANG_XINYA_ELECTRONIC_TECHNOLOGY 0x12b8U // Zhejiang Xinya Electronic Technology Co., Ltd.
#define UHS_VID_E28 0x12b9U // E28
#define UHS_VID_LICENSED_BY_SONY_COMPUTER_ENTERTAINMENT_AMERICA 0x12baU // Licensed by Sony Computer Entertainment America
#define UHS_VID_GEMBIRD 0x12bdU // Gembird
#define UHS_VID_AUTOCUE_GROUP 0x12c4U // Autocue Group Ltd
#define UHS_VID_DEXIN_1 0x12cfU // DEXIN
#define UHS_VID_HUAWEI_TECHNOLOGIES 0x12d1U // Huawei Technologies Co., Ltd.
#define UHS_VID_LINE_TECH_INDUSTRIAL 0x12d2U // LINE TECH INDUSTRIAL CO., LTD.
#define UHS_VID_EMS_DR_THOMAS_WUENSCHE 0x12d6U // EMS Dr. Thomas Wuensche
#define UHS_VID_BETTER_WIRE_FACTORY 0x12d7U // BETTER WIRE FACTORY CO., LTD.
#define UHS_VID_ARANEUS_INFORMATION_SYSTEMS_OY 0x12d8U // Araneus Information Systems Oy
#define UHS_VID_WALDORF_MUSIC 0x12e6U // Waldorf Music GmbH
#define UHS_VID_TAPWAVE 0x12efU // Tapwave, Inc.
#define UHS_VID_DYNAMIC_SYSTEM_ELECTRONICS 0x12f5U // Dynamic System Electronics Corp.
#define UHS_VID_MEMOREX_PRODUCTS 0x12f7U // Memorex Products, Inc.
#define UHS_VID_AIN_COMM_TECHNOLOGY 0x12fdU // AIN Comm. Technology Co., Ltd
#define UHS_VID_FASCINATING_ELECTRONICS 0x12ffU // Fascinating Electronics, Inc.
#define UHS_VID_TRANSCEND_INFORMATION 0x1307U // Transcend Information, Inc.
#define UHS_VID_SHUTTLE_1 0x1308U // Shuttle, Inc.
#define UHS_VID_ROPER 0x1310U // Roper
#define UHS_VID_ICS_ELECTRONICS 0x1312U // ICS Electronics
#define UHS_VID_THORLABS 0x1313U // ThorLabs
#define UHS_VID_NATURAL_POINT 0x131dU // Natural Point
#define UHS_VID_ENVARA 0x132aU // Envara Inc.
#define UHS_VID_KONICA_MINOLTA 0x132bU // Konica Minolta
#define UHS_VID_KEMPER_DIGITAL 0x133eU // Kemper Digital GmbH
#define UHS_VID_MOBILITY 0x1342U // Mobility
#define UHS_VID_CITIZEN_SYSTEMS 0x1343U // Citizen Systems
#define UHS_VID_SINO_LITE_TECHNOLOGY 0x1345U // Sino Lite Technology Corp.
#define UHS_VID_MORAVIAN_INSTRUMENTS 0x1347U // Moravian Instruments
#define UHS_VID_KATSURAGAWA_ELECTRIC 0x1348U // Katsuragawa Electric Co., Ltd.
#define UHS_VID_PANJIT_INTERNATIONAL 0x134cU // PanJit International Inc.
#define UHS_VID_DIGBYS_BITPILE_INC_DBA_D_BIT 0x134eU // Digby's Bitpile, Inc. DBA D Bit
#define UHS_VID_PANDE_MICROCOMPUTER_SYSTEMS 0x1357U // P&E Microcomputer Systems
#define UHS_VID_CONTROL_DEVELOPMENT 0x135fU // Control Development Inc.
#define UHS_VID_SEGGER 0x1366U // SEGGER
#define UHS_VID_STEC 0x136bU // STEC
#define UHS_VID_ANDOR_TECHNOLOGY 0x136eU // Andor Technology Ltd.
#define UHS_VID_SWISSBIT 0x1370U // Swissbit
#define UHS_VID_CNET_TECHNOLOGY 0x1371U // CNet Technology Inc.
#define UHS_VID_VIMTRON_ELECTRONICS 0x1376U // Vimtron Electronics Co., Ltd.
#define UHS_VID_SCAPS 0x137bU // SCAPS GmbH
#define UHS_VID_NETGEAR_2 0x1385U // Netgear, Inc
#define UHS_VID_VALIDITY_SENSORS 0x138aU // Validity Sensors, Inc.
#define UHS_VID_JUNGO 0x138eU // Jungo LTD
#define UHS_VID_TOMTOM_BV 0x1390U // TOMTOM B.V.
#define UHS_VID_IDEALTEK 0x1391U // IdealTEK, Inc.
#define UHS_VID_SENNHEISER_COMMUNICATIONS 0x1395U // Sennheiser Communications
#define UHS_VID_BEHRINGER_INTERNATIONAL 0x1397U // BEHRINGER International GmbH
#define UHS_VID_Q_TEC 0x1398U // Q-tec
#define UHS_VID_BALTECH 0x13adU // Baltech
#define UHS_VID_PERKINELMER_OPTOELECTRONICS 0x13b0U // PerkinElmer Optoelectronics
#define UHS_VID_LINKSYS_2 0x13b1U // Linksys
#define UHS_VID_ALESIS 0x13b2U // Alesis
#define UHS_VID_NIPPON_DICS 0x13b3U // Nippon Dics Co., Ltd.
#define UHS_VID_PCPLAY 0x13baU // PCPlay
#define UHS_VID_RICOH_PRINTING_SYSTEMS 0x13beU // Ricoh Printing Systems, Ltd.
#define UHS_VID_JYETAI_PRECISION_INDUSTRIAL 0x13caU // JyeTai Precision Industrial Co., Ltd.
#define UHS_VID_WISAIR 0x13cfU // Wisair Ltd.
#define UHS_VID_TECHSAN_ELECTRONICS 0x13d0U // Techsan Electronics Co., Ltd.
#define UHS_VID_A_MAX_TECHNOLOGY_MACAO_COMMERCIAL_OFFSHORE 0x13d1U // A-Max Technology Macao Commercial Offshore Co. Ltd.
#define UHS_VID_SHARK_MULTIMEDIA_1 0x13d2U // Shark Multimedia
#define UHS_VID_IMC_NETWORKS 0x13d3U // IMC Networks
#define UHS_VID_GUIDANCE_SOFTWARE 0x13d7U // Guidance Software, Inc.
#define UHS_VID_ALEREON 0x13dcU // ALEREON, INC.
#define UHS_VID_ITECH_DYNAMIC_LIMITED 0x13ddU // i.Tech Dynamic Limited
#define UHS_VID_KAIBO_WIRE_AND_CABLE_SHENZHEN 0x13e1U // Kaibo Wire & Cable (Shenzhen) Co., Ltd.
#define UHS_VID_RANE 0x13e5U // Rane
#define UHS_VID_TECHNOSCOPE 0x13e6U // TechnoScope Co., Ltd.
#define UHS_VID_HENGSTLER 0x13eaU // Hengstler
#define UHS_VID_ZYDACRON 0x13ecU // Zydacron
#define UHS_VID_MOSART 0x13eeU // MosArt
#define UHS_VID_INITIO_CORPORATION 0x13fdU // Initio Corporation
#define UHS_VID_KINGSTON_TECHNOLOGY_COMPANY_1 0x13feU // Kingston Technology Company Inc.
#define UHS_VID_AXXION_GROUP 0x1400U // Axxion Group Corp.
#define UHS_VID_BOWE_BELL_AND_HOWELL 0x1402U // Bowe Bell & Howell
#define UHS_VID_SITRONIX 0x1403U // Sitronix
#define UHS_VID_IDS_IMAGING_DEVELOPMENT_SYSTEMS 0x1409U // IDS Imaging Development Systems GmbH
#define UHS_VID_TELECHIPS 0x140eU // Telechips, Inc.
#define UHS_VID_NOVATEL_WIRELESS_1 0x1410U // Novatel Wireless
#define UHS_VID_NAM_TAI_EANDE_PRODUCTS_LTD_OR_OMNIVISION_TECHNOLOGIES 0x1415U // Nam Tai E&E Products Ltd. or OmniVision Technologies, Inc.
#define UHS_VID_ABILITY_ENTERPRISE 0x1419U // ABILITY ENTERPRISE CO., LTD.
#define UHS_VID_SENSOR_TECHNOLOGY 0x1421U // Sensor Technology
#define UHS_VID_VEGA_TECHNOLOGIES_INDUSTRIAL_AUSTRIA 0x1429U // Vega Technologies Industrial (Austria) Co.
#define UHS_VID_THALES_E_TRANSACTIONS 0x142aU // Thales E-Transactions
#define UHS_VID_ARBITER_SYSTEMS 0x142bU // Arbiter Systems, Inc.
#define UHS_VID_REDOCTANE 0x1430U // RedOctane
#define UHS_VID_PERTECH_RESOURCES 0x1431U // Pertech Resources, Inc.
#define UHS_VID_WISTRON_NEWEB 0x1435U // Wistron NeWeb
#define UHS_VID_DENALI_SOFTWARE 0x1436U // Denali Software, Inc.
#define UHS_VID_ALTEK_CORPORATION 0x143cU // Altek Corporation
#define UHS_VID_DIGILENT 0x1443U // Digilent
#define UHS_VID_XJGROUP 0x1446U // X.J.GROUP
#define UHS_VID_RADIO_SHACK 0x1453U // Radio Shack
#define UHS_VID_EXTENDING_WIRE_AND_CABLE 0x1456U // Extending Wire & Cable Co., Ltd.
#define UHS_VID_FIRST_INTERNATIONAL_COMPUTER_1 0x1457U // First International Computer, Inc.
#define UHS_VID_TRUST 0x145fU // Trust
#define UHS_VID_TATUNG 0x1460U // Tatung Co.
#define UHS_VID_STACCATO_COMMUNICATIONS 0x1461U // Staccato Communications
#define UHS_VID_MICRO_STAR_INTERNATIONAL_1 0x1462U // Micro Star International
#define UHS_VID_HUAWEI_3COM 0x1472U // Huawei-3Com
#define UHS_VID_FORMOSA_INDUSTRIAL_COMPUTING 0x147aU // Formosa Industrial Computing, Inc.
#define UHS_VID_UPEK 0x147eU // Upek
#define UHS_VID_HAMA_GMBH_AND_CO_KG 0x147fU // Hama GmbH & Co., KG
#define UHS_VID_VAILLANT 0x1482U // Vaillant
#define UHS_VID_ELSA_AG_HEX_ 0x1484U // Elsa AG [hex]
#define UHS_VID_SILICOM_1 0x1485U // Silicom
#define UHS_VID_DSP_GROUP 0x1487U // DSP Group, Ltd.
#define UHS_VID_EVATRONIX 0x148eU // EVATRONIX SA
#define UHS_VID_RALINK_TECHNOLOGY 0x148fU // Ralink Technology, Corp.
#define UHS_VID_FUTRONIC_TECHNOLOGY 0x1491U // Futronic Technology Co. Ltd.
#define UHS_VID_SUUNTO 0x1493U // Suunto
#define UHS_VID_PANSTRONG_COMPANY 0x1497U // Panstrong Company Ltd.
#define UHS_VID_MICROTEK_INTERNATIONAL_1 0x1498U // Microtek International Inc.
#define UHS_VID_IMAGINATION_TECHNOLOGIES 0x149aU // Imagination Technologies
#define UHS_VID_WIDEVIEW_TECHNOLOGY 0x14aaU // WideView Technology Inc.
#define UHS_VID_CTK_CORPORATION 0x14adU // CTK Corporation
#define UHS_VID_PRINTRONIX 0x14aeU // Printronix Inc.
#define UHS_VID_ATP_ELECTRONICS 0x14afU // ATP Electronics Inc.
#define UHS_VID_STARTECHCOM 0x14b0U // StarTech.com Ltd.
#define UHS_VID_RALINK_TECHNOLOGY_1 0x14b2U // Ralink Technology, Corp.
#define UHS_VID_ROCKWELL_AUTOMATION 0x14c0U // Rockwell Automation, Inc.
#define UHS_VID_GEMLIGHT_COMPUTER 0x14c2U // Gemlight Computer, Ltd
#define UHS_VID_ZYTRONIC 0x14c8U // Zytronic
#define UHS_VID_SUPER_TOP 0x14cdU // Super Top
#define UHS_VID_JAMER_INDUSTRIES 0x14d8U // JAMER INDUSTRIES CO., LTD.
#define UHS_VID_RARITAN_COMPUTER 0x14ddU // Raritan Computer, Inc.
#define UHS_VID_WINRADIO_COMMUNICATIONS 0x14e0U // WiNRADiO Communications
#define UHS_VID_DIALOGUE_TECHNOLOGY 0x14e1U // Dialogue Technology Corp.
#define UHS_VID_SAIN_INFORMATION_AND_COMMUNICATIONS 0x14e5U // SAIN Information & Communications Co., Ltd.
#define UHS_VID_PLANEX_COMMUNICATIONS_1 0x14eaU // Planex Communications
#define UHS_VID_SHURE 0x14edU // Shure Inc.
#define UHS_VID_TECHNISAT_DIGITAL 0x14f7U // TechniSat Digital GmbH
#define UHS_VID_ELLISYS_1 0x1500U // Ellisys
#define UHS_VID_PINE_TUM_ENTERPRISE 0x1501U // Pine-Tum Enterprise Co., Ltd.
#define UHS_VID_FIRST_INTERNATIONAL_COMPUTER_2 0x1509U // First International Computer, Inc.
#define UHS_VID_MEDMOBILE 0x1513U // medMobile
#define UHS_VID_ACTEL 0x1514U // Actel
#define UHS_VID_COMPUSA 0x1516U // CompUSA
#define UHS_VID_CHESHIRE_ENGINEERING 0x1518U // Cheshire Engineering Corp.
#define UHS_VID_COMNEON 0x1519U // Comneon
#define UHS_VID_BITWIRE 0x1520U // Bitwire Corp.
#define UHS_VID_ENE_TECHNOLOGY_1 0x1524U // ENE Technology Inc
#define UHS_VID_SILICON_PORTALS 0x1527U // Silicon Portals
#define UHS_VID_UBIQUAM 0x1529U // UBIQUAM Co., Ltd.
#define UHS_VID_THESYCON_SYSTEMSOFTWARE_AND_CONSULTING 0x152aU // Thesycon Systemsoftware & Consulting GmbH
#define UHS_VID_MIR_SRL 0x152bU // MIR Srl
#define UHS_VID_JMICRON_TECHNOLOGY_CORP_JMICRON_USA_TECHNOLOGY 0x152dU // JMicron Technology Corp. / JMicron USA Technology Corp.
#define UHS_VID_LG_HLDS 0x152eU // LG (HLDS)
#define UHS_VID_RAZER_USA 0x1532U // Razer USA, Ltd
#define UHS_VID_TERRATEC_ELECTRONIC_1 0x153bU // TerraTec Electronic GmbH
#define UHS_VID_U_BLOX_AG 0x1546U // U-Blox AG
#define UHS_VID_SG_INTEC_LTD_AND_CO_KG 0x1547U // SG Intec Ltd & Co KG
#define UHS_VID_CELECTRONIC 0x154aU // Celectronic GmbH
#define UHS_VID_PNY 0x154bU // PNY
#define UHS_VID_CONNECTCOUNTY_HOLDINGS_BERHAD 0x154dU // ConnectCounty Holdings Berhad
#define UHS_VID_DANDM_HOLDINGS_INC_DENONMARANTZ 0x154eU // D&M Holdings, Inc. (Denon/Marantz)
#define UHS_VID_SNBC 0x154fU // SNBC CO., Ltd
#define UHS_VID_PROLINK_MICROSYSTEMS 0x1554U // Prolink Microsystems Corp.
#define UHS_VID_OQO 0x1557U // OQO
#define UHS_VID_SUNF_PU_TECHNOLOGY 0x1568U // Sunf Pu Technology Co., Ltd
#define UHS_VID_QUANTUM_CORPORATION 0x156fU // Quantum Corporation
#define UHS_VID_ALLTOP_TECHNOLOGY 0x1570U // ALLTOP TECHNOLOGY CO., LTD.
#define UHS_VID_KETRON_SRL 0x157bU // Ketron SRL
#define UHS_VID_TRENDNET 0x157eU // TRENDnet
#define UHS_VID_FIBERLINE 0x1582U // Fiberline
#define UHS_VID_SMA_TECHNOLOGIE_AG 0x1587U // SMA Technologie AG
#define UHS_VID_OAKLEY 0x158dU // Oakley Inc.
#define UHS_VID_JDS_UNIPHASE_CORPORATION_JDSU 0x158eU // JDS Uniphase Corporation (JDSU)
#define UHS_VID_KUNSHAN_GUOJI_ELECTRONICS 0x1598U // Kunshan Guoji Electronics Co., Ltd.
#define UHS_VID_FREESCALE_SEMICONDUCTOR 0x15a2U // Freescale Semiconductor, Inc.
#define UHS_VID_AFATECH_TECHNOLOGIES 0x15a4U // Afatech Technologies, Inc.
#define UHS_VID_TEAMS_POWER_LIMITED 0x15a8U // Teams Power Limited
#define UHS_VID_GEMTEK 0x15a9U // Gemtek
#define UHS_VID_GEARWAY_ELECTRONICS_DONG_GUAN 0x15aaU // Gearway Electronics (Dong Guan) Co., Ltd.
#define UHS_VID_VMWARE_1 0x15adU // VMware Inc.
#define UHS_VID_OLIMEX 0x15baU // Olimex Ltd.
#define UHS_VID_XL_IMAGING 0x15c0U // XL Imaging
#define UHS_VID_SOUNDGRAPH 0x15c2U // SoundGraph Inc.
#define UHS_VID_ADVANCE_MULTIMEDIA_INTERNET_TECHNOLOGY_INC_AMIT 0x15c5U // Advance Multimedia Internet Technology Inc. (AMIT)
#define UHS_VID_LABORATOIRES_MXM 0x15c6U // Laboratoires MXM
#define UHS_VID_KTF_TECHNOLOGIES 0x15c8U // KTF Technologies
#define UHS_VID_D_BOX_TECHNOLOGIES 0x15c9U // D-Box Technologies
#define UHS_VID_TEXTECH_INTERNATIONAL 0x15caU // Textech International Ltd.
#define UHS_VID_COULOMB_ELECTRONICS 0x15d5U // Coulomb Electronics Ltd.
#define UHS_VID_TRUST_INTERNATIONAL_BV_1 0x15d9U // Trust International B.V.
#define UHS_VID_HYNIX_SEMICONDUCTOR 0x15dcU // Hynix Semiconductor Inc.
#define UHS_VID_SEONG_JI_INDUSTRIAL 0x15e0U // Seong Ji Industrial Co., Ltd.
#define UHS_VID_RSA 0x15e1U // RSA
#define UHS_VID_NUMARK 0x15e4U // Numark
#define UHS_VID_SOHOWARE 0x15e8U // SohoWare
#define UHS_VID_PACIFIC_DIGITAL 0x15e9U // Pacific Digital Corp.
#define UHS_VID_BELCARRA_TECHNOLOGIES 0x15ecU // Belcarra Technologies Corp.
#define UHS_VID_HANFTEK 0x15f4U // HanfTek
#define UHS_VID_TASCAM 0x1604U // Tascam
#define UHS_VID_UMAX_1 0x1606U // Umax
#define UHS_VID_INSIDE_OUT_NETWORKS_HEX_ 0x1608U // Inside Out Networks [hex]
#define UHS_VID_VIA_TECHNOLOGIES_1 0x160aU // VIA Technologies, Inc.
#define UHS_VID_INRO 0x160eU // INRO
#define UHS_VID_AMOI_ELECTRONICS 0x1614U // Amoi Electronics
#define UHS_VID_SONY_1 0x1617U // Sony Corp.
#define UHS_VID_L_AND_K_PRECISION_TECHNOLOGY 0x1619U // L & K Precision Technology Co., Ltd.
#define UHS_VID_WIONICS_RESEARCH 0x1621U // Wionics Research
#define UHS_VID_STONESTREET_ONE 0x1628U // Stonestreet One, Inc.
#define UHS_VID_AIRGO_NETWORKS 0x162aU // Airgo Networks Inc.
#define UHS_VID_WIQUEST_COMMUNICATIONS 0x162fU // WiQuest Communications, Inc.
#define UHS_VID_2WIRE_1 0x1630U // 2Wire, Inc.
#define UHS_VID_GOOD_WAY_TECHNOLOGY 0x1631U // Good Way Technology
#define UHS_VID_ENTREGA_HEX_ 0x1645U // Entrega [hex]
#define UHS_VID_SOFTEC_MICROSYSTEMS 0x1649U // SofTec Microsystems
#define UHS_VID_CHIPX 0x164aU // ChipX
#define UHS_VID_MATRIX_VISION 0x164cU // Matrix Vision GmbH
#define UHS_VID_STRUCK_INNOVATIVE_SYSTEME 0x1657U // Struck Innovative Systeme GmbH
#define UHS_VID_FRONTIER_DESIGN_GROUP 0x165bU // Frontier Design Group
#define UHS_VID_KONDO_KAGAKU 0x165cU // Kondo Kagaku
#define UHS_VID_CREATIX_POLYMEDIA 0x1660U // Creatix Polymedia GmbH
#define UHS_VID_GIGA_TMS 0x1667U // GIGA-TMS INC.
#define UHS_VID_ACTIONTEC_ELECTRONICS_INC_HEX_ 0x1668U // Actiontec Electronics, Inc. [hex]
#define UHS_VID_PIKRON_LTD_HEX_ 0x1669U // PiKRON Ltd. [hex]
#define UHS_VID_CLIPSAL 0x166aU // Clipsal
#define UHS_VID_CHINA_HUADA_INTEGRATED_CIRCUIT_DESIGN_GROUP_CO_LTD_CIDC_GROUP 0x1677U // China Huada Integrated Circuit Design (Group) Co., Ltd. (CIDC Group)
#define UHS_VID_TOTAL_PHASE 0x1679U // Total Phase
#define UHS_VID_GOLDEN_BRIDGE_ELECTECH_1 0x1680U // Golden Bridge Electech Inc.
#define UHS_VID_PREVO_TECHNOLOGIES 0x1681U // Prevo Technologies, Inc.
#define UHS_VID_MAXWISE_PRODUCTION_ENTERPRISE 0x1682U // Maxwise Production Enterprise Ltd.
#define UHS_VID_GODSPEED_COMPUTER 0x1684U // Godspeed Computer Corp.
#define UHS_VID_DELOCK 0x1685U // Delock
#define UHS_VID_ZOOM_CORPORATION 0x1686U // ZOOM Corporation
#define UHS_VID_KINGMAX_DIGITAL 0x1687U // Kingmax Digital Inc.
#define UHS_VID_SAAB 0x1688U // Saab AB
#define UHS_VID_RAZER_USA_1 0x1689U // Razer USA, Ltd
#define UHS_VID_ATHEROS_COMMUNICATIONS_1 0x168cU // Atheros Communications
#define UHS_VID_ASKEY_COMPUTER_CORP_HEX_ 0x1690U // Askey Computer Corp. [hex]
#define UHS_VID_HITACHI_VIDEO_AND_INFORMATION_SYSTEM 0x1696U // Hitachi Video and Information System, Inc.
#define UHS_VID_VTEC_TEST 0x1697U // VTec Test, Inc.
#define UHS_VID_SHENZHEN_ZHENGERYA_CABLE 0x16a5U // Shenzhen Zhengerya Cable Co., Ltd.
#define UHS_VID_UNIGRAF 0x16a6U // Unigraf
#define UHS_VID_GLOBAL_SUN_TECHNOLOGY_1 0x16abU // Global Sun Technology
#define UHS_VID_DONGGUAN_CHINGLUNG_WIRE_AND_CABLE 0x16acU // Dongguan ChingLung Wire & Cable Co., Ltd.
#define UHS_VID_ISTATION 0x16b4U // iStation
#define UHS_VID_PERSENTEC 0x16b5U // Persentec, Inc.
#define UHS_VID_VAN_OOIJEN_TECHNISCHE_INFORMATICA 0x16c0U // Van Ooijen Technische Informatica
#define UHS_VID_WIRELESS_CABLES 0x16caU // Wireless Cables, Inc.
#define UHS_VID_SILEX_TECHNOLOGY 0x16ccU // silex technology, Inc.
#define UHS_VID_MCS 0x16d0U // MCS
#define UHS_VID_SUPREMA 0x16d1U // Suprema Inc.
#define UHS_VID_FRONTLINE_TEST_EQUIPMENT 0x16d3U // Frontline Test Equipment, Inc.
#define UHS_VID_ANYDATA_CORPORATION 0x16d5U // AnyDATA Corporation
#define UHS_VID_JABLOCOM_SRO 0x16d6U // JABLOCOM s.r.o.
#define UHS_VID_CMOTECH 0x16d8U // CMOTECH Co., Ltd.
#define UHS_VID_WIENER_PLEIN_AND_BAUS 0x16dcU // Wiener, Plein & Baus
#define UHS_VID_KING_BILLION_ELECTRONICS 0x16dfU // King Billion Electronics Co., Ltd.
#define UHS_VID_GN_RESOUND_AS 0x16f0U // GN ReSound A/S
#define UHS_VID_FUTURELOGIC 0x16f5U // Futurelogic Inc.
#define UHS_VID_BLUEVIEW_TECHNOLOGIES 0x1706U // BlueView Technologies, Inc.
#define UHS_VID_ARTIMI 0x1707U // ARTIMI
#define UHS_VID_SWISSONIC 0x170bU // Swissonic
#define UHS_VID_AVNERA 0x170dU // Avnera
#define UHS_VID_LEICA_MICROSYSTEMS 0x1711U // Leica Microsystems
#define UHS_VID_MEYER_INSTRUMENTS_MIS 0x1724U // Meyer Instruments (MIS)
#define UHS_VID_VITESSE_SEMICONDUCTOR 0x1725U // Vitesse Semiconductor
#define UHS_VID_AXESSTEL 0x1726U // Axesstel, Inc.
#define UHS_VID_WALTOP_INTERNATIONAL 0x172fU // Waltop International Corp.
#define UHS_VID_CELLINK_TECHNOLOGY 0x1733U // Cellink Technology Co., Ltd
#define UHS_VID_CANON_IMAGING_SYSTEM_TECHNOLOGIES 0x1736U // CANON IMAGING SYSTEM TECHNOLOGIES INC.
#define UHS_VID_LINKSYS_3 0x1737U // Linksys
#define UHS_VID_QSENN 0x173dU // QSENN
#define UHS_VID_SENAO 0x1740U // Senao
#define UHS_VID_GENERAL_ATOMICS 0x1743U // General Atomics
#define UHS_VID_MQP_ELECTRONICS 0x1748U // MQP Electronics
#define UHS_VID_ASMEDIA_TECHNOLOGY 0x174cU // ASMedia Technology Inc.
#define UHS_VID_SYNTEK 0x174fU // Syntek
#define UHS_VID_GERTEC_TELECOMUNICACOES_LTDA 0x1753U // GERTEC Telecomunicacoes Ltda.
#define UHS_VID_ENENSYS_TECHNOLOGIES 0x1756U // ENENSYS Technologies
#define UHS_VID_LUCIDPORT_TECHNOLOGY 0x1759U // LucidPort Technology, Inc.
#define UHS_VID_ASUSTEK_COMPUTER_INC_WRONG_ID 0x1761U // ASUSTek Computer, Inc. (wrong ID)
#define UHS_VID_SYSTEM_LEVEL_SOLUTIONS 0x1772U // System Level Solutions, Inc.
#define UHS_VID_AROWANA 0x1776U // Arowana
#define UHS_VID_SWEEX 0x177fU // Sweex
#define UHS_VID_MULTIPLE_VENDORS 0x1781U // Multiple Vendors
#define UHS_VID_SPREADTRUM_COMMUNICATIONS 0x1782U // Spreadtrum Communications Inc.
#define UHS_VID_TOPSEED_TECHNOLOGY 0x1784U // TopSeed Technology Corp.
#define UHS_VID_ATI_AIB 0x1787U // ATI AIB
#define UHS_VID_SHENZHEN_LITKCONN_TECHNOLOGY 0x1788U // ShenZhen Litkconn Technology Co., Ltd.
#define UHS_VID_PRINTREX 0x1796U // Printrex, Inc.
#define UHS_VID_JALCO 0x1797U // JALCO CO., LTD.
#define UHS_VID_THALES_NORWAY_AS 0x1799U // Thales Norway A/S
#define UHS_VID_RICAVISION_INTERNATIONAL 0x179dU // Ricavision International, Inc.
#define UHS_VID_SAMSON_TECHNOLOGIES 0x17a0U // Samson Technologies Corp.
#define UHS_VID_CONCEPT2 0x17a4U // Concept2
#define UHS_VID_ADVANCED_CONNECTION_TECHNOLOGY 0x17a5U // Advanced Connection Technology Inc.
#define UHS_VID_MICOMSOFT 0x17a7U // MICOMSOFT CO., LTD.
#define UHS_VID_KAMSTRUP_AS 0x17a8U // Kamstrup A/S
#define UHS_VID_GREY_INNOVATION 0x17b3U // Grey Innovation
#define UHS_VID_LUNATONE 0x17b5U // Lunatone
#define UHS_VID_SAURIS 0x17baU // SAURIS GmbH
#define UHS_VID_SINGIM_INTERNATIONAL 0x17c3U // Singim International Corp.
#define UHS_VID_NATIVE_INSTRUMENTS 0x17ccU // Native Instruments
#define UHS_VID_HIP_HING_CABLE_AND_PLUG_MFY 0x17cfU // Hip Hing Cable & Plug Mfy. Ltd.
#define UHS_VID_SANFORD_LP 0x17d0U // Sanford L.P.
#define UHS_VID_KOREA_TECHTRON 0x17d3U // Korea Techtron Co., Ltd.
#define UHS_VID_DISPLAYLINK 0x17e9U // DisplayLink
#define UHS_VID_CORNICE 0x17ebU // Cornice, Inc.
#define UHS_VID_LENOVO 0x17efU // Lenovo
#define UHS_VID_WAVESENSE 0x17f4U // WaveSense
#define UHS_VID_KK_ROCKY 0x17f5U // K.K. Rocky
#define UHS_VID_UNICOMP 0x17f6U // Unicomp, Inc
#define UHS_VID_ADVANTECH 0x1809U // Advantech
#define UHS_VID_TWINHAN 0x1822U // Twinhan
#define UHS_VID_GWO_JINN_INDUSTRIES 0x1831U // Gwo Jinn Industries Co., Ltd.
#define UHS_VID_HUIZHOU_SHENGHUA_INDUSTRIAL 0x1832U // Huizhou Shenghua Industrial Co., Ltd.
#define UHS_VID_VIVOPHONE 0x183dU // VIVOphone
#define UHS_VID_VAISALA 0x1843U // Vaisala
#define UHS_VID_ASROCK_INCORPORATION 0x1849U // ASRock Incorporation
#define UHS_VID_GYROCOM_CANDC 0x1852U // GYROCOM C&C Co., LTD
#define UHS_VID_MEMORY_DEVICES 0x1854U // Memory Devices Ltd.
#define UHS_VID_COMPRO 0x185bU // Compro
#define UHS_VID_TECH_TECHNOLOGY_INDUSTRIAL_COMPANY 0x1861U // Tech Technology Industrial Company
#define UHS_VID_TERIDIAN_SEMICONDUCTOR 0x1862U // Teridian Semiconductor Corp.
#define UHS_VID_NEXIO_1 0x1870U // Nexio Co., Ltd
#define UHS_VID_AVEO_TECHNOLOGY 0x1871U // Aveo Technology Corp.
#define UHS_VID_NAVILOCK 0x1873U // Navilock
#define UHS_VID_ALIENWARE_CORPORATION 0x187cU // Alienware Corporation
#define UHS_VID_SIANO_MOBILE_SILICON 0x187fU // Siano Mobile Silicon
#define UHS_VID_VAST_TECHNOLOGIES_1 0x1892U // Vast Technologies, Inc.
#define UHS_VID_TOPSEED 0x1894U // Topseed
#define UHS_VID_EVERTOP_WIRE_CABLE 0x1897U // Evertop Wire Cable Co.
#define UHS_VID_3SHAPE_AS 0x189fU // 3Shape A/S
#define UHS_VID_CSSN 0x18a4U // CSSN
#define UHS_VID_VERBATIM 0x18a5U // Verbatim, Ltd
#define UHS_VID_PETALYNX 0x18b1U // Petalynx
#define UHS_VID_E3C_TECHNOLOGIES 0x18b4U // e3C Technologies
#define UHS_VID_MIKKON_TECHNOLOGY_LIMITED 0x18b6U // Mikkon Technology Limited
#define UHS_VID_ZOTEK_ELECTRONIC 0x18b7U // Zotek Electronic Co., Ltd.
#define UHS_VID_AMIT_TECHNOLOGY 0x18c5U // AMIT Technology, Inc.
#define UHS_VID_ECAMM 0x18cdU // Ecamm
#define UHS_VID_GOOGLE 0x18d1U // Google Inc.
#define UHS_VID_STARLINE_INTERNATIONAL_GROUP_LIMITED 0x18d5U // Starline International Group Limited
#define UHS_VID_KABA 0x18d9U // Kaba
#define UHS_VID_LKC_TECHNOLOGIES 0x18dcU // LKC Technologies, Inc.
#define UHS_VID_PLANON_SYSTEM_SOLUTIONS 0x18ddU // Planon System Solutions Inc.
#define UHS_VID_FITIPOWER_INTEGRATED_TECHNOLOGY 0x18e3U // Fitipower Integrated Technology Inc
#define UHS_VID_QCOM 0x18e8U // Qcom
#define UHS_VID_MATROX_GRAPHICS 0x18eaU // Matrox Graphics, Inc.
#define UHS_VID_ARKMICRO_TECHNOLOGIES 0x18ecU // Arkmicro Technologies Inc.
#define UHS_VID_FINEARCH 0x18fdU // FineArch Inc.
#define UHS_VID_GEMBIRD_1 0x1908U // GEMBIRD
#define UHS_VID_MOTOROLA_GSG 0x190dU // Motorola GSG
#define UHS_VID_ALCO_DIGITAL_DEVICES_LIMITED 0x1914U // Alco Digital Devices Limited
#define UHS_VID_NORDIC_SEMICONDUCTOR_ASA 0x1915U // Nordic Semiconductor ASA
#define UHS_VID_FITLINXX 0x1923U // FitLinxx
#define UHS_VID_NEXTWINDOW 0x1926U // NextWindow
#define UHS_VID_AVAGO_TECHNOLOGIES_PTE 0x192fU // Avago Technologies, Pte.
#define UHS_VID_SHENZHEN_XIANHE_TECHNOLOGY 0x1930U // Shenzhen Xianhe Technology Co., Ltd.
#define UHS_VID_NINGBO_BROAD_TELECOMMUNICATION 0x1931U // Ningbo Broad Telecommunication Co., Ltd.
#define UHS_VID_FEATURE_INTEGRATION_TECHNOLOGY_INC_FINTEK 0x1934U // Feature Integration Technology Inc. (Fintek)
#define UHS_VID_DREAM_LINK 0x1941U // Dream Link
#define UHS_VID_SENSORAY 0x1943U // Sensoray Co., Inc.
#define UHS_VID_LAB126 0x1949U // Lab126, Inc.
#define UHS_VID_PRESONUS_AUDIO_ELECTRONICS 0x194fU // PreSonus Audio Electronics, Inc.
#define UHS_VID_HYPERSTONE_AG 0x1951U // Hyperstone AG
#define UHS_VID_IRONKEY 0x1953U // Ironkey Inc.
#define UHS_VID_RADIIENT_TECHNOLOGIES 0x1954U // Radiient Technologies
#define UHS_VID_ITRON_TECHNOLOGY_IONE 0x195dU // Itron Technology iONE
#define UHS_VID_UNIDEN_CORPORATION 0x1965U // Uniden Corporation
#define UHS_VID_CASIO_HITACHI_MOBILE_COMMUNICATIONS 0x1967U // CASIO HITACHI Mobile Communications Co., Ltd.
#define UHS_VID_WISPRO_TECHNOLOGY 0x196bU // Wispro Technology Inc.
#define UHS_VID_DANE_ELEC_CORP_USA 0x1970U // Dane-Elec Corp. USA
#define UHS_VID_DONGGUAN_GUNEETAL_WIRE_AND_CABLE 0x1975U // Dongguan Guneetal Wire & Cable Co., Ltd.
#define UHS_VID_CHIPSBRAND_MICROELECTRONICS_HK 0x1976U // Chipsbrand Microelectronics (HK) Co., Ltd.
#define UHS_VID_T_LOGIC 0x1977U // T-Logic
#define UHS_VID_LEUZE_ELECTRONIC 0x197dU // Leuze electronic
#define UHS_VID_NUCONN_TECHNOLOGY 0x1989U // Nuconn Technology Corp.
#define UHS_VID_BECEEM_COMMUNICATIONS 0x198fU // Beceem Communications Inc.
#define UHS_VID_ACRON_PRECISION_INDUSTRIAL 0x1990U // Acron Precision Industrial Co., Ltd.
#define UHS_VID_TRILLIUM_TECHNOLOGY_PTY 0x1995U // Trillium Technology Pty. Ltd.
#define UHS_VID_PIXELINK 0x1996U // PixeLINK
#define UHS_VID_MICROSTRAIN 0x199bU // MicroStrain, Inc.
#define UHS_VID_THE_IMAGING_SOURCE_EUROPE 0x199eU // The Imaging Source Europe GmbH
#define UHS_VID_BENICA_CORPORATION 0x199fU // Benica Corporation
#define UHS_VID_BIFORST_TECHNOLOGY 0x19a8U // Biforst Technology Inc.
#define UHS_VID_BODELIN 0x19abU // Bodelin
#define UHS_VID_S_LIFE 0x19afU // S Life
#define UHS_VID_BATRONIX 0x19b2U // Batronix
#define UHS_VID_CELESTRON 0x19b4U // Celestron
#define UHS_VID_B_AND_W_GROUP 0x19b5U // B & W Group
#define UHS_VID_INFOTECH_LOGISTIC 0x19b6U // Infotech Logistic, LLC
#define UHS_VID_DATA_ROBOTICS 0x19b9U // Data Robotics
#define UHS_VID_FUTUBA 0x19c2U // Futuba
#define UHS_VID_MINDTRIBE 0x19caU // Mindtribe
#define UHS_VID_PARROT 0x19cfU // Parrot SA
#define UHS_VID_ZTE_WCDMA_TECHNOLOGIES_MSM 0x19d2U // ZTE WCDMA Technologies MSM
#define UHS_VID_KFI_PRINTERS 0x19dbU // KFI Printers
#define UHS_VID_WEIDUAN_ELECTRONIC_ACCESSORY_SZ 0x19e1U // WeiDuan Electronic Accessory (S.Z.) Co., Ltd.
#define UHS_VID_INDUSTRIAL_TECHNOLOGY_RESEARCH_INSTITUTE 0x19e8U // Industrial Technology Research Institute
#define UHS_VID_PAK_HENG_TECHNOLOGY_SHENZHEN 0x19efU // Pak Heng Technology (Shenzhen) Co., Ltd.
#define UHS_VID_RODE_MICROPHONES 0x19f7U // RODE Microphones
#define UHS_VID_GAMPAQ_COLTD 0x19faU // Gampaq Co.Ltd
#define UHS_VID_DYNEX 0x19ffU // Dynex
#define UHS_VID_BELLWOOD_INTERNATIONAL 0x1a08U // Bellwood International, Inc.
#define UHS_VID_USB_IF_NON_WORKSHOP 0x1a0aU // USB-IF non-workshop
#define UHS_VID_KES 0x1a12U // KES Co., Ltd.
#define UHS_VID_VEHO 0x1a1dU // Veho
#define UHS_VID_AMPHENOL_EAST_ASIA 0x1a25U // Amphenol East Asia Ltd.
#define UHS_VID_SEAGATE_BRANDED_SOLUTIONS 0x1a2aU // Seagate Branded Solutions
#define UHS_VID_CHINA_RESOURCE_SEMICO 0x1a2cU // China Resource Semico Co., Ltd
#define UHS_VID_QUANTA_MICROSYSTEMS 0x1a32U // Quanta Microsystems, Inc.
#define UHS_VID_ACRUX 0x1a34U // ACRUX
#define UHS_VID_BIWIN_TECHNOLOGY 0x1a36U // Biwin Technology Ltd.
#define UHS_VID_TERMINUS_TECHNOLOGY 0x1a40U // Terminus Technology Inc.
#define UHS_VID_ACTION_ELECTRONICS 0x1a41U // Action Electronics Co., Ltd.
#define UHS_VID_VASCO_DATA_SECURITY_INTERNATIONAL 0x1a44U // VASCO Data Security International
#define UHS_VID_SILICON_IMAGE 0x1a4aU // Silicon Image
#define UHS_VID_SAFEBOOT_INTERNATIONAL_BV 0x1a4bU // SafeBoot International B.V.
#define UHS_VID_TANDBERG_DATA 0x1a5aU // Tandberg Data
#define UHS_VID_ABBOTT_DIABETES_CARE 0x1a61U // Abbott Diabetes Care
#define UHS_VID_SPANSION 0x1a6aU // Spansion Inc.
#define UHS_VID_SAMYOUNG_ELECTRONICS 0x1a6dU // SamYoung Electronics Co., Ltd
#define UHS_VID_GLOBAL_UNICHIP 0x1a6eU // Global Unichip Corp.
#define UHS_VID_SAGEM_ORGA 0x1a6fU // Sagem Orga GmbH
#define UHS_VID_PHYSIK_INSTRUMENTE 0x1a72U // Physik Instrumente
#define UHS_VID_BAYER_HEALTH_CARE 0x1a79U // Bayer Health Care LLC
#define UHS_VID_LUMBERG_CONNECT_GMBH_AND_CO_KG 0x1a7bU // Lumberg Connect GmbH & Co. KG
#define UHS_VID_EVOLUENT 0x1a7cU // Evoluent
#define UHS_VID_HOLTEK_SEMICONDUCTOR_1 0x1a81U // Holtek Semiconductor, Inc.
#define UHS_VID_QINHENG_ELECTRONICS 0x1a86U // QinHeng Electronics
#define UHS_VID_DYNALITH_SYSTEMS 0x1a89U // Dynalith Systems Co., Ltd.
#define UHS_VID_SGS_TAIWAN 0x1a8bU // SGS Taiwan Ltd.
#define UHS_VID_BANDRICH 0x1a8dU // BandRich, Inc.
#define UHS_VID_LEICA_CAMERA_AG 0x1a98U // Leica Camera AG
#define UHS_VID_DATA_DRIVE_THRU 0x1aa4U // Data Drive Thru, Inc.
#define UHS_VID_UBEACON_TECHNOLOGIES 0x1aa5U // UBeacon Technologies, Inc.
#define UHS_VID_EFORTUNE_TECHNOLOGY 0x1aa6U // eFortune Technology Corp.
#define UHS_VID_KEETOUCH 0x1aadU // KeeTouch
#define UHS_VID_RIGOL_TECHNOLOGIES 0x1ab1U // Rigol Technologies
#define UHS_VID_SALCOMP_PLC 0x1acbU // Salcomp Plc
#define UHS_VID_MIDIPLUS 0x1accU // Midiplus Co, Ltd.
#define UHS_VID_DESAY_WIRE 0x1ad1U // Desay Wire Co., Ltd.
#define UHS_VID_APS 0x1ad4U // APS
#define UHS_VID_SEL_C662_SERIAL_CABLE 0x1adbU // SEL C662 Serial Cable
#define UHS_VID_IC_DESIGN_REINHARD_GOTTINGER 0x1ae4U // ic-design Reinhard Gottinger GmbH
#define UHS_VID_X_TENSIONS 0x1ae7U // X-TENSIONS
#define UHS_VID_HIGH_TOP_PRECISION_ELECTRONIC 0x1aedU // High Top Precision Electronic Co., Ltd.
#define UHS_VID_CONNTECH_ELECTRONIC_SUZHOU_CORPORATION 0x1aefU // Conntech Electronic (Suzhou) Corporation
#define UHS_VID_CONNECT_ONE 0x1af1U // Connect One Ltd.
#define UHS_VID_A_EBERLE_GMBH_AND_CO_KG 0x1afeU // A. Eberle GmbH & Co. KG
#define UHS_VID_MEILHAUS_ELECTRONIC 0x1b04U // Meilhaus Electronic GmbH
#define UHS_VID_BLUTRONICS_SRL 0x1b0eU // BLUTRONICS S.r.l.
#define UHS_VID_CORSAIR 0x1b1cU // Corsair
#define UHS_VID_MSTAR_SEMICONDUCTOR 0x1b20U // MStar Semiconductor, Inc.
#define UHS_VID_WILINX 0x1b22U // WiLinx Corp.
#define UHS_VID_CELLEX_POWER_PRODUCTS 0x1b26U // Cellex Power Products, Inc.
#define UHS_VID_CURRENT_ELECTRONICS 0x1b27U // Current Electronics Inc.
#define UHS_VID_NAVISIS 0x1b28U // NAVIsis Inc.
#define UHS_VID_UGOBE_LIFE_FORMS 0x1b32U // Ugobe Life Forms, Inc.
#define UHS_VID_VIXS_SYSTEMS 0x1b36U // ViXS Systems, Inc.
#define UHS_VID_IPASSION_TECHNOLOGY 0x1b3bU // iPassion Technology Inc.
#define UHS_VID_GENERALPLUS_TECHNOLOGY 0x1b3fU // Generalplus Technology Inc.
#define UHS_VID_ENERGIZER_HOLDINGS 0x1b47U // Energizer Holdings, Inc.
#define UHS_VID_PLASTRON_PRECISION 0x1b48U // Plastron Precision Co., Ltd.
#define UHS_VID_ARH 0x1b52U // ARH Inc.
#define UHS_VID_KS_TERMINALS 0x1b59U // K.S. Terminals Inc.
#define UHS_VID_CHAO_ZHOU_KAI_YUAN_ELECTRIC 0x1b5aU // Chao Zhou Kai Yuan Electric Co., Ltd.
#define UHS_VID_THE_HONG_KONG_STANDARDS_AND_TESTING_CENTRE 0x1b65U // The Hong Kong Standards and Testing Centre Ltd.
#define UHS_VID_FUSHICAI 0x1b71U // Fushicai
#define UHS_VID_ATERGI_TECHNOLOGY 0x1b72U // ATERGI TECHNOLOGY CO., LTD.
#define UHS_VID_FRESCO_LOGIC 0x1b73U // Fresco Logic
#define UHS_VID_OVISLINK 0x1b75U // Ovislink Corp.
#define UHS_VID_LEGEND_SILICON 0x1b76U // Legend Silicon Corp.
#define UHS_VID_AFATECH 0x1b80U // Afatech
#define UHS_VID_DONGGUAN_GUANSHANG_ELECTRONICS 0x1b86U // Dongguan Guanshang Electronics Co., Ltd.
#define UHS_VID_SHENMING_ELECTRON_DONG_GUAN 0x1b88U // ShenMing Electron (Dong Guan) Co., Ltd.
#define UHS_VID_ALTIUM_LIMITED 0x1b8cU // Altium Limited
#define UHS_VID_E_MOVE_TECHNOLOGY 0x1b8dU // e-MOVE Technology Co., Ltd.
#define UHS_VID_AMLOGIC 0x1b8eU // Amlogic, Inc.
#define UHS_VID_MA_LABS 0x1b8fU // MA LABS, Inc.
#define UHS_VID_N_TRIG 0x1b96U // N-Trig
#define UHS_VID_YMAX_COMMUNICATIONS 0x1b98U // YMax Communications Corp.
#define UHS_VID_SHENZHEN_YUANCHUAN_ELECTRONIC 0x1b99U // Shenzhen Yuanchuan Electronic
#define UHS_VID_JINQ_CHERN_ENTERPRISE 0x1ba1U // JINQ CHERN ENTERPRISE CO., LTD.
#define UHS_VID_LITE_METALS_AND_PLASTIC_SHENZHEN 0x1ba2U // Lite Metals & Plastic (Shenzhen) Co., Ltd.
#define UHS_VID_EMBER_CORPORATION 0x1ba4U // Ember Corporation
#define UHS_VID_ABILIS_SYSTEMS 0x1ba6U // Abilis Systems
#define UHS_VID_CHINA_TELECOMMUNICATION_TECHNOLOGY_LABS 0x1ba8U // China Telecommunication Technology Labs
#define UHS_VID_HARMONIX_MUSIC 0x1badU // Harmonix Music
#define UHS_VID_VUZIX_CORPORATION 0x1baeU // Vuzix Corporation
#define UHS_VID_T_AND_A_MOBILE_PHONES 0x1bbbU // T & A Mobile Phones
#define UHS_VID_FORD_MOTOR 0x1bc4U // Ford Motor Co.
#define UHS_VID_AVIXE_TECHNOLOGY_CHINA 0x1bc5U // AVIXE Technology (China) Ltd.
#define UHS_VID_TELIT_WIRELESS_SOLUTIONS 0x1bc7U // Telit Wireless Solutions
#define UHS_VID_CONTAC_CABLE_INDUSTRIAL_LIMITED 0x1bceU // Contac Cable Industrial Limited
#define UHS_VID_SUNPLUS_INNOVATION_TECHNOLOGY 0x1bcfU // Sunplus Innovation Technology Inc.
#define UHS_VID_HANGZHOU_RIYUE_ELECTRONIC 0x1bd0U // Hangzhou Riyue Electronic Co., Ltd.
#define UHS_VID_BG_SYSTEMS 0x1bd5U // BG Systems, Inc.
#define UHS_VID_P_TWO_INDUSTRIES 0x1bdeU // P-TWO INDUSTRIES, INC.
#define UHS_VID_SHENZHEN_TONGYUAN_NETWORK_COMMUNICATION_CABLES 0x1befU // Shenzhen Tongyuan Network-Communication Cables Co., Ltd
#define UHS_VID_REALVISION 0x1bf0U // RealVision Inc.
#define UHS_VID_EXTRANET_SYSTEMS 0x1bf5U // Extranet Systems Inc.
#define UHS_VID_ORIENT_SEMICONDUCTOR_ELECTRONICS 0x1bf6U // Orient Semiconductor Electronics, Ltd.
#define UHS_VID_TOUCHPACK 0x1bfdU // TouchPack
#define UHS_VID_KRETON_CORPORATION 0x1c02U // Kreton Corporation
#define UHS_VID_QNAP_SYSTEM 0x1c04U // QNAP System Inc.
#define UHS_VID_IONICS_EMS 0x1c0cU // Ionics EMS, Inc.
#define UHS_VID_RELM_WIRELESS 0x1c0dU // Relm Wireless
#define UHS_VID_LANTERRA_INDUSTRIAL 0x1c10U // Lanterra Industrial Co., Ltd.
#define UHS_VID_ALECTRONIC_LIMITED 0x1c13U // ALECTRONIC LIMITED
#define UHS_VID_DATEL_ELECTRONICS 0x1c1aU // Datel Electronics Ltd.
#define UHS_VID_VOLKSWAGEN_OF_AMERICA 0x1c1bU // Volkswagen of America, Inc.
#define UHS_VID_GOLDVISH 0x1c1fU // Goldvish S.A.
#define UHS_VID_FUJI_ELECTRIC_DEVICE_TECHNOLOGY 0x1c20U // Fuji Electric Device Technology Co., Ltd.
#define UHS_VID_ADDMM 0x1c21U // ADDMM LLC
#define UHS_VID_ZHONGSHAN_CHIANG_YU_ELECTRIC 0x1c22U // ZHONGSHAN CHIANG YU ELECTRIC CO., LTD.
#define UHS_VID_SHANGHAI_HAIYING_ELECTRONICS 0x1c26U // Shanghai Haiying Electronics Co., Ltd.
#define UHS_VID_HUIYANG_D_AND_S_CABLE 0x1c27U // HuiYang D & S Cable Co., Ltd.
#define UHS_VID_ELSTER 0x1c29U // Elster GmbH
#define UHS_VID_LS_CABLE 0x1c31U // LS Cable Ltd.
#define UHS_VID_SPRINGCARD 0x1c34U // SpringCard
#define UHS_VID_AUTHORIZER_TECHNOLOGIES 0x1c37U // Authorizer Technologies, Inc.
#define UHS_VID_NONIN_MEDICAL 0x1c3dU // NONIN MEDICAL INC.
#define UHS_VID_WEP_PERIPHERALS 0x1c3eU // Wep Peripherals
#define UHS_VID_EZPROTOTYPES 0x1c40U // EZPrototypes
#define UHS_VID_CHERNG_WEEI_TECHNOLOGY 0x1c49U // Cherng Weei Technology Corp.
#define UHS_VID_SIGMA_MICRO 0x1c4fU // SiGma Micro
#define UHS_VID_PHILIPS_AND_LITE_ON_DIGITAL_SOLUTIONS_CORPORATION 0x1c6bU // Philips & Lite-ON Digital Solutions Corporation
#define UHS_VID_SKYDIGITAL 0x1c6cU // Skydigital Inc.
#define UHS_VID_AMT 0x1c73U // AMT
#define UHS_VID_KAETAT_INDUSTRIAL 0x1c77U // Kaetat Industrial Co., Ltd.
#define UHS_VID_DATASCOPE 0x1c78U // Datascope Corp.
#define UHS_VID_UNIGEN_CORPORATION 0x1c79U // Unigen Corporation
#define UHS_VID_LIGHTUNING_TECHNOLOGY 0x1c7aU // LighTuning Technology Inc.
#define UHS_VID_LUXSHARE_PRECISION_INDUSTRY_SHENZHEN 0x1c7bU // LUXSHARE PRECISION INDUSTRY (SHENZHEN) CO., LTD.
#define UHS_VID_SCHOMAECKER 0x1c83U // Schomaecker GmbH
#define UHS_VID_2N_TELEKOMUNIKACE_AS 0x1c87U // 2N TELEKOMUNIKACE a.s.
#define UHS_VID_SOMAGIC 0x1c88U // Somagic, Inc.
#define UHS_VID_HONGKONG_WEIDIDA_ELECTRON_LIMITED 0x1c89U // HONGKONG WEIDIDA ELECTRON LIMITED
#define UHS_VID_ASTRON_INTERNATIONAL 0x1c8eU // ASTRON INTERNATIONAL CORP.
#define UHS_VID_ALPINE_ELECTRONICS 0x1c98U // ALPINE ELECTRONICS, INC.
#define UHS_VID_OMEGA_TECHNOLOGY 0x1c9eU // OMEGA TECHNOLOGY
#define UHS_VID_ACCARIO 0x1ca0U // ACCARIO Inc.
#define UHS_VID_SYMWAVE 0x1ca1U // Symwave
#define UHS_VID_KINSTONE 0x1cacU // Kinstone
#define UHS_VID_ACES_ELECTRONIC 0x1cb3U // Aces Electronic Co., Ltd.
#define UHS_VID_OPEX_CORPORATION 0x1cb4U // OPEX CORPORATION
#define UHS_VID_IDEACOM_TECHNOLOGY 0x1cb6U // IdeaCom Technology Inc.
#define UHS_VID_LUMINARY_MICRO 0x1cbeU // Luminary Micro Inc.
#define UHS_VID_FORTAT_SKYMARK_INDUSTRIAL_COMPANY 0x1cbfU // FORTAT SKYMARK INDUSTRIAL COMPANY
#define UHS_VID_PLANTSENSE 0x1cc0U // PlantSense
#define UHS_VID_NEXTWAVE_BROADBAND 0x1ccaU // NextWave Broadband Inc.
#define UHS_VID_BODATONG_TECHNOLOGY_SHENZHEN 0x1ccdU // Bodatong Technology (Shenzhen) Co., Ltd.
#define UHS_VID_ADP_CORPORATION 0x1cd4U // adp corporation
#define UHS_VID_FIRECOMMS 0x1cd5U // Firecomms Ltd.
#define UHS_VID_ANTONIO_PRECISE_PRODUCTS_MANUFACTORY 0x1cd6U // Antonio Precise Products Manufactory Ltd.
#define UHS_VID_TELECOMMUNICATIONS_TECHNOLOGY_ASSOCIATION_TTA 0x1cdeU // Telecommunications Technology Association (TTA)
#define UHS_VID_WONTEN_TECHNOLOGY 0x1cdfU // WonTen Technology Co., Ltd.
#define UHS_VID_EDIMAX_TECHNOLOGY 0x1ce0U // EDIMAX TECHNOLOGY CO., LTD.
#define UHS_VID_AMPHENOL_KAE 0x1ce1U // Amphenol KAE
#define UHS_VID_DRESDEN_ELEKTRONIK 0x1cf1U // Dresden Elektronik
#define UHS_VID_ANDES_TECHNOLOGY_CORPORATION 0x1cfcU // ANDES TECHNOLOGY CORPORATION
#define UHS_VID_FLEXTRONICS_DIGITAL_DESIGN_JAPAN 0x1cfdU // Flextronics Digital Design Japan, LTD.
#define UHS_VID_ICON 0x1d03U // iCON
#define UHS_VID_SOLID_MOTION 0x1d07U // Solid-Motion
#define UHS_VID_NINGBO_HENTEK_DRAGON_ELECTRONICS 0x1d08U // NINGBO HENTEK DRAGON ELECTRONICS CO., LTD.
#define UHS_VID_TECHFAITH_WIRELESS_TECHNOLOGY_LIMITED 0x1d09U // TechFaith Wireless Technology Limited
#define UHS_VID_JOHNSON_CONTROLS_INC_THE_AUTOMOTIVE_BUSINESS_UNIT 0x1d0aU // Johnson Controls, Inc. The Automotive Business Unit
#define UHS_VID_HAN_HUA_CABLE_AND_WIRE_TECHNOLOGY_JX 0x1d0bU // HAN HUA CABLE & WIRE TECHNOLOGY (J.X.) CO., LTD.
#define UHS_VID_SONIX_TECHNOLOGY 0x1d0fU // Sonix Technology Co., Ltd.
#define UHS_VID_ALPHA_SAT_TECHNOLOGY_LIMITED 0x1d14U // ALPHA-SAT TECHNOLOGY LIMITED
#define UHS_VID_C_THRU_MUSIC 0x1d17U // C-Thru Music Ltd.
#define UHS_VID_DEXATEK_TECHNOLOGY 0x1d19U // Dexatek Technology Ltd.
#define UHS_VID_DIOSTECH 0x1d1fU // Diostech Co., Ltd.
#define UHS_VID_SAMTACK 0x1d20U // SAMTACK INC.
#define UHS_VID_ASUS 0x1d27U // ASUS
#define UHS_VID_DREAM_CHEEKY 0x1d34U // Dream Cheeky
#define UHS_VID_TOUCH 0x1d45U // Touch
#define UHS_VID_PEGATRON_CORPORATION 0x1d4dU // PEGATRON CORPORATION
#define UHS_VID_OPENMOKO 0x1d50U // OpenMoko, Inc.
#define UHS_VID_XENTA 0x1d57U // Xenta
#define UHS_VID_SMARTRONIX 0x1d5bU // Smartronix, Inc.
#define UHS_VID_LINUX_FOUNDATION 0x1d6bU // Linux Foundation
#define UHS_VID_CITIZEN 0x1d90U // Citizen
#define UHS_VID_ACTIONS_MICROELECTRONICS 0x1de1U // Actions Microelectronics Co.
#define UHS_VID_QUALCOMM_OPTION 0x1e0eU // Qualcomm / Option
#define UHS_VID_POINT_GREY_RESEARCH 0x1e10U // Point Grey Research, Inc.
#define UHS_VID_MIRION_TECHNOLOGIES_DOSIMETRY_SERVICES_DIVISION 0x1e17U // Mirion Technologies Dosimetry Services Division
#define UHS_VID_LUMENSION_SECURITY 0x1e1dU // Lumension Security
#define UHS_VID_INVIA 0x1e1fU // INVIA
#define UHS_VID_FESTO_AG_AND_CO_KG 0x1e29U // Festo AG & Co. KG
#define UHS_VID_CHIPSBANK_MICROELECTRONICS_1 0x1e3dU // Chipsbank Microelectronics Co., Ltd
#define UHS_VID_CLEVERSCOPE 0x1e41U // Cleverscope
#define UHS_VID_CUBETERNET 0x1e4eU // Cubeternet
#define UHS_VID_TYPEMATRIX 0x1e54U // TypeMatrix
#define UHS_VID_TREKSTOR_GMBH_AND_CO_KG 0x1e68U // TrekStor GmbH & Co. KG
#define UHS_VID_NZXT 0x1e71U // NZXT
#define UHS_VID_COBY_ELECTRONICS_CORPORATION 0x1e74U // Coby Electronics Corporation
#define UHS_VID_ROCCAT 0x1e7dU // ROCCAT
#define UHS_VID_NUCORE_TECHNOLOGY 0x1ebbU // NuCORE Technology, Inc.
#define UHS_VID_AIRTIES_WIRELESS_NETWORKS 0x1edaU // AirTies Wireless Networks
#define UHS_VID_BLACKMAGIC_DESIGN 0x1edbU // Blackmagic design
#define UHS_VID_ONDA_COMMUNICATION_SPA 0x1ee8U // ONDA COMMUNICATION S.p.a.
#define UHS_VID_EADS_DEUTSCHLAND 0x1ef6U // EADS Deutschland GmbH
#define UHS_VID_CAL_COMP 0x1f28U // Cal-Comp
#define UHS_VID_ONDA_UNVERIFIED 0x1f3aU // Onda (unverified)
#define UHS_VID_THE_NEAT_COMPANY 0x1f44U // The Neat Company
#define UHS_VID_H_TRONIC 0x1f48U // H-TRONIC GmbH
#define UHS_VID_G_TEK_ELECTRONICS_GROUP 0x1f4dU // G-Tek Electronics Group
#define UHS_VID_ALIPH 0x1f6fU // Aliph
#define UHS_VID_INNOSTOR_TECHNOLOGY_CORPORATION 0x1f75U // Innostor Technology Corporation
#define UHS_VID_TANDBERG 0x1f82U // TANDBERG
#define UHS_VID_ALERE 0x1f84U // Alere, Inc.
#define UHS_VID_STANTUM 0x1f87U // Stantum
#define UHS_VID_UBIQUITI_NETWORKS 0x1f9bU // Ubiquiti Networks, Inc.
#define UHS_VID_SAMSUNG_OPTO_ELECTRONCS 0x1fabU // Samsung Opto-Electroncs Co., Ltd.
#define UHS_VID_DELPHIN_TECHNOLOGY_AG 0x1fbdU // Delphin Technology AG
#define UHS_VID_NXP_SEMICONDUCTORS 0x1fc9U // NXP Semiconductors
#define UHS_VID_ILX_LIGHTWAVE_CORPORATION 0x1fdeU // ILX Lightwave Corporation
#define UHS_VID_VERTEX_WIRELESS 0x1fe7U // Vertex Wireless Co., Ltd.
#define UHS_VID_CVT_ELECTRONICSCOLTD 0x1ff7U // CVT Electronics.Co.,Ltd
#define UHS_VID_IDEOFY 0x1fffU // Ideofy Inc.
#define UHS_VID_D_LINK 0x2001U // D-Link Corp.
#define UHS_VID_DAP_TECHNOLOGIES 0x2002U // DAP Technologies
#define UHS_VID_DETECTOMAT 0x2003U // detectomat
#define UHS_VID_RELOOP 0x200cU // Reloop
#define UHS_VID_PCTV_SYSTEMS 0x2013U // PCTV Systems
#define UHS_VID_PLANEX_1 0x2019U // PLANEX
#define UHS_VID_ENCORE_ELECTRONICS 0x203dU // Encore Electronics Inc.
#define UHS_VID_HAUPPAUGE 0x2040U // Hauppauge
#define UHS_VID_TEXAS_INSTRUMENTS_2 0x2047U // Texas Instruments
#define UHS_VID_NANO_RIVER_TECHNOLOGY 0x2058U // Nano River Technology
#define UHS_VID_TAICANG_TANDW_ELECTRONICS 0x2077U // Taicang T&W Electronics Co. Ltd
#define UHS_VID_BARNES_AND_NOBLE 0x2080U // Barnes & Noble
#define UHS_VID_SIMPASS 0x2086U // SIMPASS
#define UHS_VID_CANDO 0x2087U // Cando
#define UHS_VID_CLAY_LOGIC 0x20a0U // Clay Logic
#define UHS_VID_XMOS 0x20b1U // XMOS Ltd
#define UHS_VID_HANVON 0x20b3U // Hanvon
#define UHS_VID_QI_HARDWARE 0x20b7U // Qi Hardware
#define UHS_VID_MINICIRCUITS 0x20ceU // Minicircuits
#define UHS_VID_SIMTEC_ELECTRONICS 0x20dfU // Simtec Electronics
#define UHS_VID_NET_NEW_ELECTRONIC_TECHNOLOGY 0x20f1U // NET New Electronic Technology GmbH
#define UHS_VID_TRENDNET_1 0x20f4U // TRENDnet
#define UHS_VID_XIMEA 0x20f7U // XIMEA
#define UHS_VID_RT_SYSTEMS 0x2100U // RT Systems
#define UHS_VID_ACTIONSTAR 0x2101U // ActionStar
#define UHS_VID_VIA_LABS 0x2109U // VIA Labs, Inc.
#define UHS_VID_SOFTKINETIC 0x2113U // Softkinetic
#define UHS_VID_ADVANCED_SILICON 0x2149U // Advanced Silicon S.A.
#define UHS_VID_CREATIVE_UNKNOWN 0x2162U // Creative (?)
#define UHS_VID_GW_INSTEK 0x2184U // GW Instek
#define UHS_VID_EMOTIV_SYSTEMS_PTY 0x21a1U // Emotiv Systems Pty. Ltd.
#define UHS_VID_AGECODAGIS_SARL 0x21d6U // Agecodagis SARL
#define UHS_VID_MACALLY_1 0x2222U // MacAlly
#define UHS_VID_SAMWOO_ENTERPRISE 0x2227U // SAMWOO Enterprise
#define UHS_VID_SILICON_MOTION_1 0x2232U // Silicon Motion
#define UHS_VID_RADIOSHACK_CORPORATION 0x2233U // RadioShack Corporation
#define UHS_VID_KOBO 0x2237U // Kobo Inc.
#define UHS_VID_MORPHO 0x225dU // Morpho
#define UHS_VID_8D_TECHNOLOGIES 0x228dU // 8D Technologies inc.
#define UHS_VID_PIE_DIGITAL 0x22a6U // Pie Digital, Inc.
#define UHS_VID_MOTOROLA_PCS 0x22b8U // Motorola PCS
#define UHS_VID_ETURBOTOUCH_TECHNOLOGY 0x22b9U // eTurboTouch Technology, Inc.
#define UHS_VID_TECHNOLOGY_INNOVATION_HOLDINGS 0x22baU // Technology Innovation Holdings, Ltd
#define UHS_VID_PINNACLE_SYSTEMS_1 0x2304U // Pinnacle Systems, Inc.
#define UHS_VID_SHINING_TECHNOLOGIES_INC_HEX_ 0x2318U // Shining Technologies, Inc. [hex]
#define UHS_VID_ARDUINO 0x2341U // Arduino SA
#define UHS_VID_PUMATRONIX_LTDA 0x2373U // Pumatronix Ltda
#define UHS_VID_DIGITALWAY_1 0x2375U // Digit@lway, Inc.
#define UHS_VID_SANHO_DIGITAL_ELECTRONICS 0x2406U // SANHO Digital Electronics Co., Ltd.
#define UHS_VID_AESSENT_TECHNOLOGY 0x2443U // Aessent Technology Ltd
#define UHS_VID_TRIPP_LITE_1 0x2478U // Tripp-Lite
#define UHS_VID_MAXXTER 0x248aU // Maxxter
#define UHS_VID_M2TECH_SRL 0x249cU // M2Tech s.r.l.
#define UHS_VID_PARATRONIC 0x24e1U // Paratronic
#define UHS_VID_TWINMOS_1 0x2632U // TwinMOS
#define UHS_VID_XSENS 0x2639U // Xsens
#define UHS_VID_ELECTRONICS_FOR_IMAGING_INC_HEX_ 0x2650U // Electronics For Imaging, Inc. [hex]
#define UHS_VID_SUNDTEK 0x2659U // Sundtek
#define UHS_VID_BASLER_AG 0x2676U // Basler AG
#define UHS_VID_CITIZEN_1 0x2730U // Citizen
#define UHS_VID_DIGITALWAY_2 0x2735U // DigitalWay
#define UHS_VID_NHJ 0x2770U // NHJ, Ltd
#define UHS_VID_THINGM 0x27b8U // ThingM
#define UHS_VID_ASUSTEK_COMPUTER_1 0x2821U // ASUSTek Computer Inc.
#define UHS_VID_TOPTRONIC_INDUSTRIAL 0x2899U // Toptronic Industrial Co., Ltd
#define UHS_VID_DRACALRAPHNET_TECHNOLOGIES 0x289bU // Dracal/Raphnet technologies
#define UHS_VID_JOLLA_OY 0x2931U // Jolla Oy
#define UHS_VID_DOG_HUNTER_AG 0x2a03U // dog hunter AG
#define UHS_VID_RTD_EMBEDDED_TECHNOLOGIES 0x2a37U // RTD Embedded Technologies, Inc.
#define UHS_VID_MEIZU 0x2a45U // Meizu Corp.
#define UHS_VID_PLANEX_COMMUNICATIONS_2 0x2c02U // Planex Communications
#define UHS_VID_DOLPHIN_PERIPHERALS 0x2c1aU // Dolphin Peripherals
#define UHS_VID_FUJITSU_1 0x2fb2U // Fujitsu, Ltd
#define UHS_VID_EAGLETRON_1 0x3125U // Eagletron
#define UHS_VID_NAVINI_NETWORKS 0x3136U // Navini Networks
#define UHS_VID_WHANAM_ELECTRONICS 0x3176U // Whanam Electronics Co., Ltd
#define UHS_VID_LINK_INSTRUMENTS 0x3195U // Link Instruments
#define UHS_VID_VIDZMEDIA_PTE 0x3275U // VidzMedia Pte Ltd
#define UHS_VID_INLINE 0x3333U // InLine
#define UHS_VID_AEI 0x3334U // AEI
#define UHS_VID_YAKUMO 0x3340U // Yakumo
#define UHS_VID_LEAGUER_MICROELECTRONICS_LME 0x3344U // Leaguer Microelectronics (LME)
#define UHS_VID_MICRO_STAR 0x3504U // Micro Star
#define UHS_VID_POWER_QUOTIENT_INTERNATIONAL_1 0x3538U // Power Quotient International Co., Ltd
#define UHS_VID_DIVA 0x3579U // DIVA
#define UHS_VID_SHARKOON 0x357dU // Sharkoon
#define UHS_VID_INVIBRO 0x3636U // InVibro
#define UHS_VID_WEM 0x3838U // WEM
#define UHS_VID_NATIONAL_INSTRUMENTS 0x3923U // National Instruments Corp.
#define UHS_VID_I_O_DATA 0x40bbU // I-O Data
#define UHS_VID_I_ROCKS 0x4101U // i-rocks
#define UHS_VID_IRIVER_1 0x4102U // iRiver, Ltd.
#define UHS_VID_DELL_COMPUTER_1 0x413cU // Dell Computer Corp.
#define UHS_VID_USBEST_TECHNOLOGY 0x4146U // USBest Technology
#define UHS_VID_TARGUS 0x4168U // Targus
#define UHS_VID_USB_DESIGN_BY_EXAMPLE 0x4242U // USB Design by Example
#define UHS_VID_GOPRO 0x4255U // GoPro
#define UHS_VID_BROADCOM_1 0x4317U // Broadcom Corp.
#define UHS_VID_WINCHIPHEAD 0x4348U // WinChipHead
#define UHS_VID_SHUTTLE_2 0x4572U // Shuttle, Inc.
#define UHS_VID_PANRAM 0x4586U // Panram
#define UHS_VID_EMS_PRODUCTION 0x4670U // EMS Production
#define UHS_VID_MIDITECH 0x4752U // Miditech
#define UHS_VID_GW_INSTEK_1 0x4757U // GW Instek
#define UHS_VID_ACEECA 0x4766U // Aceeca
#define UHS_VID_MEMOREX 0x4855U // Memorex
#define UHS_VID_SIMPLETECH 0x4971U // SimpleTech
#define UHS_VID_MUSICAL_FIDELITY 0x4d46U // Musical Fidelity
#define UHS_VID_GRANDTEC 0x5032U // Grandtec
#define UHS_VID_LINKSYS_UNKNOWN 0x5041U // Linksys (?)
#define UHS_VID_AVERATEC_UNKNOWN 0x50c2U // Averatec (?)
#define UHS_VID_SWEEX_1 0x5173U // Sweex
#define UHS_VID_I_TETRA 0x5219U // I-Tetra
#define UHS_VID_OWON 0x5345U // Owon
#define UHS_VID_SATOSHILABS 0x534cU // SatoshiLabs
#define UHS_VID_MEYER_INSTRUMENTS_MIS_1 0x5354U // Meyer Instruments (MIS)
#define UHS_VID_TRANSMETA 0x544dU // Transmeta Corp.
#define UHS_VID_UC_LOGIC_TECHNOLOGY 0x5543U // UC-Logic Technology Corp.
#define UHS_VID_EPIPHAN_SYSTEMS 0x5555U // Epiphan Systems Inc.
#define UHS_VID_ONSPEC_ELECTRONIC 0x55aaU // OnSpec Electronic, Inc.
#define UHS_VID_GOTVIEW 0x5654U // Gotview
#define UHS_VID_UNI_TREND_GROUP_LIMITED 0x5656U // Uni-Trend Group Limited
#define UHS_VID_IRTOUCHSYSTEMS 0x595aU // IRTOUCHSYSTEMS Co. Ltd.
#define UHS_VID_ACER_2 0x5986U // Acer, Inc
#define UHS_VID_NONOLITH_LABS 0x59e3U // Nonolith Labs
#define UHS_VID_ZINWELL 0x5a57U // Zinwell
#define UHS_VID_BEHOLDER_INTERNATIONAL 0x6000U // Beholder International Ltd.
#define UHS_VID_INGENIC_SEMICONDUCTOR 0x601aU // Ingenic Semiconductor Ltd.
#define UHS_VID_SITECOM 0x6189U // Sitecom
#define UHS_VID_LIGHTINGSOFT_AG 0x6244U // LightingSoft AG
#define UHS_VID_TWINHAN_TECHNOLOGY 0x6253U // TwinHan Technology Co., Ltd
#define UHS_VID_CORELOGIC 0x636cU // CoreLogic, Inc.
#define UHS_VID_UNKNOWN_SONY_UNKNOWN 0x6472U // Unknown (Sony?)
#define UHS_VID_ARKMICRO_TECHNOLOGIES_1 0x6547U // Arkmicro Technologies Inc.
#define UHS_VID_IRTOUCHSYSTEMS_1 0x6615U // IRTOUCHSYSTEMS Co. Ltd.
#define UHS_VID_PROTOTYPE_PRODUCT_VENDOR_ID 0x6666U // Prototype product Vendor ID
#define UHS_VID_WISEGROUP 0x6677U // WiseGroup, Ltd.
#define UHS_VID_3COM_1 0x6891U // 3Com
#define UHS_VID_OPERA1 0x695cU // Opera1
#define UHS_VID_YEALINK_NETWORK_TECHNOLOGY 0x6993U // Yealink Network Technology Co., Ltd.
#define UHS_VID_SHANGHAI_JUJO_ELECTRONICS 0x6a75U // Shanghai Jujo Electronics Co., Ltd
#define UHS_VID_CME_CENTRAL_MUSIC 0x7104U // CME (Central Music Co.)
#define UHS_VID_STACKFOUNDRY 0x726cU // StackFoundry LLC
#define UHS_VID_TBS_TECHNOLOGIES_CHINA 0x734cU // TBS Technologies China
#define UHS_VID_BEIJING_STONE_TECHNOLOGY 0x7373U // Beijing STONE Technology Co. Ltd.
#define UHS_VID_EDIMAX_TECHNOLOGY_1 0x7392U // Edimax Technology Co., Ltd
#define UHS_VID_INTEL_1 0x8086U // Intel Corp.
#define UHS_VID_INTEL_2 0x8087U // Intel Corp.
#define UHS_VID_VIRTUALBOX 0x80eeU // VirtualBox
#define UHS_VID_KEIO 0x8282U // Keio
#define UHS_VID_EGO_SYSTEMS_1 0x8341U // EGO Systems, Inc.
#define UHS_VID_TRANSCEND_INFORMATION_1 0x8564U // Transcend Information, Inc.
#define UHS_VID_INTENSO_GMBG 0x8644U // Intenso GmbG
#define UHS_VID_CH_PRODUCTS_1 0x8e06U // CH Products, Inc.
#define UHS_VID_SITECOM_1 0x9016U // Sitecom
#define UHS_VID_TEVII_TECHNOLOGY 0x9022U // TeVii Technology Ltd.
#define UHS_VID_GEOLAB 0x9148U // GeoLab, Ltd
#define UHS_VID_MOSCHIP_SEMICONDUCTOR 0x9710U // MosChip Semiconductor
#define UHS_VID_BESTMEDIA_CD_RECORDABLE_GMBH_AND_CO_KG 0x9849U // Bestmedia CD Recordable GmbH & Co. KG
#define UHS_VID_ODEON 0x9999U // Odeon
#define UHS_VID_GRANDTEC_1 0x99faU // Grandtec
#define UHS_VID_J_WESTHUES 0x9ac4U // J. Westhues
#define UHS_VID_MARVELL_SEMICONDUCTOR_1 0x9e88U // Marvell Semiconductor, Inc.
#define UHS_VID_ANMO_ELECTRONICS_CORP_DINO_LITE_UNKNOWN 0xa128U // AnMo Electronics Corp. / Dino-Lite (?)
#define UHS_VID_ANMO_ELECTRONICS_CORPORATION 0xa168U // AnMo Electronics Corporation
#define UHS_VID_ASIX 0xa600U // Asix
#define UHS_VID_3COM_2 0xa727U // 3Com
#define UHS_VID_MXT 0xaaaaU // MXT
#define UHS_VID_UNKNOWN_3 0xabcdU // Unknown
#define UHS_VID_BLUE_MICROPHONES 0xb58eU // Blue Microphones
#define UHS_VID_CARD_DEVICE_EXPERT 0xc216U // Card Device Expert Co., LTD
#define UHS_VID_KEIL_SOFTWARE_1 0xc251U // Keil Software, Inc.
#define UHS_VID_CACE_TECHNOLOGIES 0xcaceU // CACE Technologies Inc.
#define UHS_VID_SMART_TECHNOLOGY_INDUSTRIAL 0xcd12U // SMART TECHNOLOGY INDUSTRIAL LTD.
#define UHS_VID_ULTIMARC 0xd208U // Ultimarc
#define UHS_VID_ULTIMARC_1 0xd209U // Ultimarc
#define UHS_VID_LOGILINK 0xd904U // LogiLink
#define UHS_VID_XORCOM 0xe4e4U // Xorcom Ltd.
#define UHS_VID_MAKINGTHINGS 0xeb03U // MakingThings
#define UHS_VID_EMPIA_TECHNOLOGY 0xeb1aU // eMPIA Technology, Inc.
#define UHS_VID_KWORLD 0xeb2aU // KWorld
#define UHS_VID_SMART_TECHNOLOGY_INDUSTRIAL_1 0xef18U // SMART TECHNOLOGY INDUSTRIAL LTD.
#define UHS_VID_HEWLETT_PACKARD_1 0xf003U // Hewlett Packard
#define UHS_VID_LEAP_MOTION 0xf182U // Leap Motion
#define UHS_VID_ATTEN_ELECTRONICS_SIGLENT_TECHNOLOGIES 0xf4ecU // Atten Electronics / Siglent Technologies
#define UHS_VID_SHENZHEN_SIGLENT 0xf4edU // Shenzhen Siglent Co., Ltd.
#define UHS_VID_HAMA_1 0xf766U // Hama
#define UHS_VID_CONRAD_ELECTRONIC_SE 0xfc08U // Conrad Electronic SE
#define UHS_VID_FNK_TECH 0xffeeU // FNK Tech
#endif

336
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_UsbCore.h Normal file
View file

@ -0,0 +1,336 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_UHS_host_h_) || defined(USBCORE_H)
#error "Never include UHS_UsbCore.h directly; include UHS_Host.h instead"
#else
#define USBCORE_H
#ifndef UHS_HOST_MAX_INTERFACE_DRIVERS
#define UHS_HOST_MAX_INTERFACE_DRIVERS 0x10U // Default maximum number of USB interface drivers
#endif
#if !defined(SYSTEM_OR_SPECIAL_YIELD)
#define SYSTEM_OR_SPECIAL_YIELD(...) VOID0
#endif
#if !defined(SYSTEM_OR_SPECIAL_YIELD_FROM_ISR)
#define SYSTEM_OR_SPECIAL_YIELD_FROM_ISR(...) SYSTEM_OR_SPECIAL_YIELD
#endif
// As we make extensions to a target interface add to UHS_HOST_MAX_INTERFACE_DRIVERS
// This offset gets calculated for supporting wide subclasses, such as HID, BT, etc.
#define UHS_HID_INDEX (UHS_HOST_MAX_INTERFACE_DRIVERS + 1)
/* Common setup data constant combinations */
//get descriptor request type
#define UHS_bmREQ_GET_DESCR (USB_SETUP_DEVICE_TO_HOST|USB_SETUP_TYPE_STANDARD|USB_SETUP_RECIPIENT_DEVICE)
//set request type for all but 'set feature' and 'set interface'
#define UHS_bmREQ_SET (USB_SETUP_HOST_TO_DEVICE|USB_SETUP_TYPE_STANDARD|USB_SETUP_RECIPIENT_DEVICE)
//get interface request type
#define UHS_bmREQ_CL_GET_INTF (USB_SETUP_DEVICE_TO_HOST|USB_SETUP_TYPE_CLASS|USB_SETUP_RECIPIENT_INTERFACE)
// D7 data transfer direction (0 - host-to-device, 1 - device-to-host)
// D6-5 Type (0- standard, 1 - class, 2 - vendor, 3 - reserved)
// D4-0 Recipient (0 - device, 1 - interface, 2 - endpoint, 3 - other, 4..31 - reserved)
// TO-DO: Use the python script to generate these.
// TO-DO: Add _all_ subclasses here.
// USB Device Classes, Subclasses and Protocols
////////////////////////////////////////////////////////////////////////////////
// Use Class Info in the Interface Descriptors
#define UHS_USB_CLASS_USE_CLASS_INFO 0x00U
////////////////////////////////////////////////////////////////////////////////
// Audio
#define UHS_USB_CLASS_AUDIO 0x01U
// Subclasses
#define UHS_USB_SUBCLASS_AUDIOCONTROL 0x01U
#define UHS_USB_SUBCLASS_AUDIOSTREAMING 0x02U
#define UHS_USB_SUBCLASS_MIDISTREAMING 0x03U
////////////////////////////////////////////////////////////////////////////////
// Communications and CDC Control
#define UHS_USB_CLASS_COM_AND_CDC_CTRL 0x02U
////////////////////////////////////////////////////////////////////////////////
// HID
#define UHS_USB_CLASS_HID 0x03U
// Subclasses
#define UHS_HID_BOOT_SUBCLASS 0x01U
// Protocols
#define UHS_HID_PROTOCOL_HIDBOOT_KEYBOARD 0x01U
#define UHS_HID_PROTOCOL_HIDBOOT_MOUSE 0x02U
////////////////////////////////////////////////////////////////////////////////
// Physical
#define UHS_USB_CLASS_PHYSICAL 0x05U
////////////////////////////////////////////////////////////////////////////////
// Image
#define UHS_USB_CLASS_IMAGE 0x06U
////////////////////////////////////////////////////////////////////////////////
// Printer
#define UHS_USB_CLASS_PRINTER 0x07U
////////////////////////////////////////////////////////////////////////////////
// Mass Storage
#define UHS_USB_CLASS_MASS_STORAGE 0x08
// Subclasses
#define UHS_BULK_SUBCLASS_SCSI_NOT_REPORTED 0x00U // De facto use
#define UHS_BULK_SUBCLASS_RBC 0x01U
#define UHS_BULK_SUBCLASS_ATAPI 0x02U // MMC-5 (ATAPI)
#define UHS_BULK_SUBCLASS_OBSOLETE1 0x03U // Was QIC-157
#define UHS_BULK_SUBCLASS_UFI 0x04U // Specifies how to interface Floppy Disk Drives to USB
#define UHS_BULK_SUBCLASS_OBSOLETE2 0x05U // Was SFF-8070i
#define UHS_BULK_SUBCLASS_SCSI 0x06U // SCSI Transparent Command Set
#define UHS_BULK_SUBCLASS_LSDFS 0x07U // Specifies how host has to negotiate access before trying SCSI
#define UHS_BULK_SUBCLASS_IEEE1667 0x08U
// Protocols
#define UHS_STOR_PROTO_CBI 0x00U // CBI (with command completion interrupt)
#define UHS_STOR_PROTO_CBI_NO_INT 0x01U // CBI (without command completion interrupt)
#define UHS_STOR_PROTO_OBSOLETE 0x02U
#define UHS_STOR_PROTO_BBB 0x50U // Bulk Only Transport
#define UHS_STOR_PROTO_UAS 0x62U
////////////////////////////////////////////////////////////////////////////////
// Hub
#define UHS_USB_CLASS_HUB 0x09U
////////////////////////////////////////////////////////////////////////////////
// CDC-Data
#define UHS_USB_CLASS_CDC_DATA 0x0AU
////////////////////////////////////////////////////////////////////////////////
// Smart-Card
#define UHS_USB_CLASS_SMART_CARD 0x0BU
////////////////////////////////////////////////////////////////////////////////
// Content Security
#define UHS_USB_CLASS_CONTENT_SECURITY 0x0DU
////////////////////////////////////////////////////////////////////////////////
// Video
#define UHS_USB_CLASS_VIDEO 0x0EU
////////////////////////////////////////////////////////////////////////////////
// Personal Healthcare
#define UHS_USB_CLASS_PERSONAL_HEALTH 0x0FU
////////////////////////////////////////////////////////////////////////////////
// Diagnostic Device
#define UHS_USB_CLASS_DIAGNOSTIC_DEVICE 0xDCU
////////////////////////////////////////////////////////////////////////////////
// Wireless Controller
#define UHS_USB_CLASS_WIRELESS_CTRL 0xE0U
////////////////////////////////////////////////////////////////////////////////
// Miscellaneous
#define UHS_USB_CLASS_MISC 0xEFU
////////////////////////////////////////////////////////////////////////////////
// Application Specific
#define UHS_USB_CLASS_APP_SPECIFIC 0xFEU
////////////////////////////////////////////////////////////////////////////////
// Vendor Specific
#define UHS_USB_CLASS_VENDOR_SPECIFIC 0xFFU
////////////////////////////////////////////////////////////////////////////////
/* USB state machine states */
#define UHS_USB_HOST_STATE_MASK 0xF0U
// Configure states, MSN == 0 --------------------------V
#define UHS_USB_HOST_STATE_DETACHED 0x00U
#define UHS_USB_HOST_STATE_DEBOUNCE 0x01U
#define UHS_USB_HOST_STATE_DEBOUNCE_NOT_COMPLETE 0x02U
#define UHS_USB_HOST_STATE_RESET_NOT_COMPLETE 0x03U
#define UHS_USB_HOST_STATE_WAIT_SOF 0x04U
#define UHS_USB_HOST_STATE_WAIT_BUS_READY 0x05U
#define UHS_USB_HOST_STATE_RESET_DEVICE 0x0AU
#define UHS_USB_HOST_STATE_CONFIGURING 0x0CU // Looks like "CO"nfig (backwards)
#define UHS_USB_HOST_STATE_CONFIGURING_DONE 0x0DU // Looks like "DO"one (backwards)
#define UHS_USB_HOST_STATE_CHECK 0x0EU
#define UHS_USB_HOST_STATE_ILLEGAL 0x0FU // Foo
// Run states, MSN != 0 --------------------------------V
#define UHS_USB_HOST_STATE_RUNNING 0x60U // Looks like "GO"
#define UHS_USB_HOST_STATE_IDLE 0x1DU // Looks like "ID"le
#define UHS_USB_HOST_STATE_ERROR 0xF0U // Looks like "FO"o
#define UHS_USB_HOST_STATE_INITIALIZE 0x10U // Looks like "I"nit
// Host SE result codes.
// Common SE results are stored in the low nybble, all interface drivers understand these plus 0x1f.
// Extended SE results are 0x10-0x1e. SE code only understands these internal to the hardware.
// Values > 0x1F are driver or other internal error conditions.
// Return these result codes from your host controller driver to match the error condition
// ALL Non-zero values are errors.
// Values not listed in this table are not handled in the base class, or any host driver.
#define UHS_HOST_ERROR_NONE 0x00U // No error
#define UHS_HOST_ERROR_BUSY 0x01U // transfer pending
#define UHS_HOST_ERROR_BADREQ 0x02U // Transfer Launch Request was bad
#define UHS_HOST_ERROR_DMA 0x03U // DMA was too short, or too long
#define UHS_HOST_ERROR_NAK 0x04U // Peripheral returned NAK
#define UHS_HOST_ERROR_STALL 0x05U // Peripheral returned STALL
#define UHS_HOST_ERROR_TOGERR 0x06U // Toggle error/ISO over-underrun
#define UHS_HOST_ERROR_WRONGPID 0x07U // Received wrong Packet ID
#define UHS_HOST_ERROR_BADBC 0x08U // Byte count is bad
#define UHS_HOST_ERROR_PIDERR 0x09U // Received Packet ID is corrupted
#define UHS_HOST_ERROR_BADRQ 0x0AU // Packet error. Increase max packet.
#define UHS_HOST_ERROR_CRC 0x0BU // USB CRC was incorrect
#define UHS_HOST_ERROR_KERR 0x0CU // K-state instead of response, usually indicates wrong speed
#define UHS_HOST_ERROR_JERR 0x0DU // J-state instead of response, usually indicates wrong speed
#define UHS_HOST_ERROR_TIMEOUT 0x0EU // Device did not respond in time
#define UHS_HOST_ERROR_BABBLE 0x0FU // Line noise/unexpected data
#define UHS_HOST_ERROR_MEM_LAT 0x10U // Error caused by memory latency.
#define UHS_HOST_ERROR_NYET 0x11U // OUT transfer accepted with NYET
// Addressing error codes
#define ADDR_ERROR_INVALID_INDEX 0xA0U
#define ADDR_ERROR_INVALID_ADDRESS 0xA1U
// Common Interface Driver error codes
#define UHS_HOST_ERROR_DEVICE_NOT_SUPPORTED 0xD1U // Driver doesn't support the device or interfaces
#define UHS_HOST_ERROR_DEVICE_INIT_INCOMPLETE 0xD2U // Init partially finished, but died.
#define UHS_HOST_ERROR_CANT_REGISTER_DEVICE_CLASS 0xD3U // There was no driver for the interface requested.
#define UHS_HOST_ERROR_ADDRESS_POOL_FULL 0xD4U // No addresses left in the address pool.
#define UHS_HOST_ERROR_HUB_ADDRESS_OVERFLOW 0xD5U // No hub addresses left. The maximum is 7.
#define UHS_HOST_ERROR_NO_ADDRESS_IN_POOL 0xD6U // Address was not allocated in the pool, thus not found.
#define UHS_HOST_ERROR_NULL_EPINFO 0xD7U // The supplied endpoint was NULL, indicates a bug or other problem.
#define UHS_HOST_ERROR_BAD_ARGUMENT 0xD8U // Indicates a range violation bug.
#define UHS_HOST_ERROR_DEVICE_DRIVER_BUSY 0xD9U // The interface driver is busy or out buffer is full, try again later.
#define UHS_HOST_ERROR_BAD_MAX_PACKET_SIZE 0xDAU // The maximum packet size was exceeded. Try again with smaller size.
#define UHS_HOST_ERROR_NO_ENDPOINT_IN_TABLE 0xDBU // The endpoint could not be found in the endpoint table.
#define UHS_HOST_ERROR_UNPLUGGED 0xDEU // Someone removed the USB device, or Vbus was turned off.
#define UHS_HOST_ERROR_NOMEM 0xDFU // Out Of Memory.
// Control request stream errors
#define UHS_HOST_ERROR_FailGetDevDescr 0xE1U
#define UHS_HOST_ERROR_FailSetDevTblEntry 0xE2U
#define UHS_HOST_ERROR_FailGetConfDescr 0xE3U
#define UHS_HOST_ERROR_END_OF_STREAM 0xEFU
// Host base class specific Error codes
#define UHS_HOST_ERROR_NOT_IMPLEMENTED 0xFEU
#define UHS_HOST_ERROR_TRANSFER_TIMEOUT 0xFFU
// SEI interaction defaults
#define UHS_HOST_TRANSFER_MAX_MS 10000 // USB transfer timeout in ms, per section 9.2.6.1 of USB 2.0 spec
#define UHS_HOST_TRANSFER_RETRY_MAXIMUM 3 // 3 retry limit for a transfer
#define UHS_HOST_DEBOUNCE_DELAY_MS 500 // settle delay in milliseconds
#define UHS_HUB_RESET_DELAY_MS 20 // hub port reset delay, 10ms recomended, but can be up to 20ms
//
// We only provide the minimum needed information for enumeration.
// Interface drivers should be able to set up what is needed with nothing more.
// A driver needs to know the following information:
// 1: address on the USB network, parent and port (aka UsbDeviceAddress)
// 2: endpoints
// 3: vid:pid, class, subclass, protocol
//
struct ENDPOINT_INFO {
uint8_t bEndpointAddress; // Endpoint address. Bit 7 indicates direction (0=OUT, 1=IN).
uint8_t bmAttributes; // Endpoint transfer type.
uint16_t wMaxPacketSize; // Maximum packet size.
uint8_t bInterval; // Polling interval in frames.
} __attribute__((packed));
struct INTERFACE_INFO {
uint8_t bInterfaceNumber;
uint8_t bAlternateSetting;
uint8_t numep;
uint8_t klass;
uint8_t subklass;
uint8_t protocol;
ENDPOINT_INFO epInfo[16];
} __attribute__((packed));
struct ENUMERATION_INFO {
uint16_t vid;
uint16_t pid;
uint16_t bcdDevice;
uint8_t klass;
uint8_t subklass;
uint8_t protocol;
uint8_t bMaxPacketSize0;
uint8_t currentconfig;
uint8_t parent;
uint8_t port;
uint8_t address;
INTERFACE_INFO interface;
} __attribute__((packed));
/* USB Setup Packet Structure */
typedef struct {
// offset description
// 0 Bit-map of request type
union {
uint8_t bmRequestType;
struct {
uint8_t recipient : 5; // Recipient of the request
uint8_t type : 2; // Type of request
uint8_t direction : 1; // Direction of data transfer
} __attribute__((packed));
} ReqType_u;
// 1 Request
uint8_t bRequest;
// 2 Depends on bRequest
union {
uint16_t wValue;
struct {
uint8_t wValueLo;
uint8_t wValueHi;
} __attribute__((packed));
} wVal_u;
// 4 Depends on bRequest
uint16_t wIndex;
// 6 Depends on bRequest
uint16_t wLength;
// 8 bytes total
} __attribute__((packed)) SETUP_PKT, *PSETUP_PKT;
// little endian :-) 8 8 8 8 16 16
#define mkSETUP_PKT8(bmReqType, bRequest, wValLo, wValHi, wInd, total) ((uint64_t)(((uint64_t)(bmReqType)))|(((uint64_t)(bRequest))<<8)|(((uint64_t)(wValLo))<<16)|(((uint64_t)(wValHi))<<24)|(((uint64_t)(wInd))<<32)|(((uint64_t)(total)<<48)))
#define mkSETUP_PKT16(bmReqType, bRequest, wVal, wInd, total) ((uint64_t)(((uint64_t)(bmReqType)))|(((uint64_t)(bRequest))<<8)|(((uint64_t)(wVal ))<<16) |(((uint64_t)(wInd))<<32)|(((uint64_t)(total)<<48)))
// Big endian -- but we aren't able to use this :-/
//#define mkSETUP_PKT8(bmReqType, bRequest, wValLo, wValHi, wInd, total) ((uint64_t)(((uint64_t)(bmReqType))<<56)|(((uint64_t)(bRequest))<<48)|(((uint64_t)(wValLo))<<40)|(((uint64_t)(wValHi))<<32)|(((uint64_t)(wInd))<<16)|((uint64_t)(total)))
//#define mkSETUP_PKT16(bmReqType, bRequest, wVal, wInd, total) ((uint64_t)(((uint64_t)(bmReqType))<<56)|(((uint64_t)(bRequest))<<48) |(((uint64_t)(wVal))<<32) |(((uint64_t)(wInd))<<16)|((uint64_t)(total)))
#endif /* USBCORE_H */

248
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_address.h Normal file
View file

@ -0,0 +1,248 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_UHS_host_h_) || defined(__ADDRESS_H__)
#error "Never include UHS_address.h directly; include UHS_Usb.h instead"
#else
#define __ADDRESS_H__
/* NAK powers. To save space in endpoint data structure, amount of retries before giving up and returning 0x4 is stored in */
/* bmNakPower as a power of 2. The actual nak_limit is then calculated as nak_limit = ( 2^bmNakPower - 1) */
#define UHS_USB_NAK_MAX_POWER 14 // NAK binary order maximum value
#define UHS_USB_NAK_DEFAULT 13 // default 16K-1 NAKs before giving up
#define UHS_USB_NAK_NOWAIT 1 // Single NAK stops transfer
#define UHS_USB_NAK_NONAK 0 // Do not count NAKs, stop retrying after USB Timeout. Try not to use this.
#define bmUSB_DEV_ADDR_PORT 0x07
#define bmUSB_DEV_ADDR_PARENT 0x78
#define bmUSB_DEV_ADDR_HUB 0x40
// TODO: embed parent?
struct UHS_EpInfo {
uint8_t epAddr; // Endpoint address
uint8_t bIface;
uint16_t maxPktSize; // Maximum packet size
union {
uint8_t epAttribs;
struct {
uint8_t bmSndToggle : 1; // Send toggle, when zero bmSNDTOG0, bmSNDTOG1 otherwise
uint8_t bmRcvToggle : 1; // Send toggle, when zero bmRCVTOG0, bmRCVTOG1 otherwise
uint8_t bmNeedPing : 1; // 1 == ping protocol needed for next out packet
uint8_t bmNakPower : 5; // Binary order for NAK_LIMIT value
} __attribute__((packed));
};
} __attribute__((packed));
// TODO: embed parent address and port into epinfo struct,
// and nuke this address stupidity.
// This is a compact scheme. Should also support full spec.
// This produces a 7 hub limit, 49 devices + 7 hubs, 56 total.
//
// 7 6 5 4 3 2 1 0
// ---------------------------------
// | | H | P | P | P | A | A | A |
// ---------------------------------
//
// H - if 1 the address is a hub address
// P - parent hub number
// A - port number of parent
//
struct UHS_DeviceAddress {
union {
struct {
uint8_t bmAddress : 3; // port number
uint8_t bmParent : 3; // parent hub address
uint8_t bmHub : 1; // hub flag
uint8_t bmReserved : 1; // reserved, must be zero
} __attribute__((packed));
uint8_t devAddress;
};
} __attribute__((packed));
struct UHS_Device {
volatile UHS_EpInfo *epinfo[UHS_HOST_MAX_INTERFACE_DRIVERS]; // endpoint info pointer
UHS_DeviceAddress address;
uint8_t epcount; // number of endpoints
uint8_t speed; // indicates device speed
} __attribute__((packed));
typedef void (*UsbDeviceHandleFunc)(UHS_Device *pdev);
class AddressPool {
UHS_EpInfo dev0ep; //Endpoint data structure used during enumeration for uninitialized device
// In order to avoid hub address duplication, this should use bits
uint8_t hubCounter; // hub counter
UHS_Device thePool[UHS_HOST_MAX_INTERFACE_DRIVERS];
// Initializes address pool entry
void UHS_NI InitEntry(uint8_t index) {
thePool[index].address.devAddress = 0;
thePool[index].epcount = 1;
thePool[index].speed = 0;
for(uint8_t i = 0; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) {
thePool[index].epinfo[i] = &dev0ep;
}
};
// Returns thePool index for a given address
uint8_t UHS_NI FindAddressIndex(uint8_t address = 0) {
for(uint8_t i = 1; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) {
if(thePool[i].address.devAddress == address)
return i;
}
return 0;
};
// Returns thePool child index for a given parent
uint8_t UHS_NI FindChildIndex(UHS_DeviceAddress addr, uint8_t start = 1) {
for(uint8_t i = (start < 1 || start >= UHS_HOST_MAX_INTERFACE_DRIVERS) ? 1 : start; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) {
if(thePool[i].address.bmParent == addr.bmAddress)
return i;
}
return 0;
};
// Frees address entry specified by index parameter
void UHS_NI FreeAddressByIndex(uint8_t index) {
// Zero field is reserved and should not be affected
if(index == 0)
return;
UHS_DeviceAddress uda = thePool[index].address;
// If a hub was switched off all port addresses should be freed
if(uda.bmHub == 1) {
for(uint8_t i = 1; (i = FindChildIndex(uda, i));)
FreeAddressByIndex(i);
// FIXME: use BIT MASKS
// If the hub had the last allocated address, hubCounter should be decremented
if(hubCounter == uda.bmAddress)
hubCounter--;
}
InitEntry(index);
}
void InitAllAddresses(void) {
for(uint8_t i = 1; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) InitEntry(i);
hubCounter = 0;
};
public:
AddressPool() {
hubCounter = 0;
// Zero address is reserved
InitEntry(0);
thePool[0].epinfo[0] = &dev0ep;
dev0ep.epAddr = 0;
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
dev0ep.maxPktSize = 0x40; //starting at 0x40 and work down
#else
dev0ep.maxPktSize = 0x08;
#endif
dev0ep.epAttribs = 0; //set DATA0/1 toggles to 0
dev0ep.bmNakPower = UHS_USB_NAK_MAX_POWER;
InitAllAddresses();
};
// Returns a pointer to a specified address entry
UHS_Device* UHS_NI GetUsbDevicePtr(uint8_t addr) {
if(!addr)
return thePool;
uint8_t index = FindAddressIndex(addr);
return (!index) ? NULL : &thePool[index];
};
// Allocates new address
uint8_t UHS_NI AllocAddress(uint8_t parent, bool is_hub = false, uint8_t port = 1) {
/* if (parent != 0 && port == 0)
USB_HOST_SERIAL.println("PRT:0"); */
UHS_DeviceAddress _parent;
_parent.devAddress = parent;
if(_parent.bmReserved || port > 7)
//if(parent > 127 || port > 7)
return 0;
// FIXME: use BIT MASKS
if(is_hub && hubCounter == 7)
return 0;
// finds first empty address entry starting from one
uint8_t index = FindAddressIndex(0);
if(!index) // if empty entry is not found
return 0;
UHS_DeviceAddress addr;
addr.devAddress = port;
addr.bmParent = _parent.bmAddress;
// FIXME: use BIT MASKS
if(is_hub) {
hubCounter++;
addr.bmHub = 1;
addr.bmAddress = hubCounter;
}
thePool[index].address = addr;
#if DEBUG_PRINTF_EXTRA_HUGE
#if defined(UHS_DEBUG_USB_ADDRESS)
printf("Address: %x (%x.%x.%x)\r\n", addr.devAddress, addr.bmHub, addr.bmParent, addr.bmAddress);
#endif
#endif
return thePool[index].address.devAddress;
};
void UHS_NI FreeAddress(uint8_t addr) {
// if the root hub is disconnected all the addresses should be initialized
if(addr == 0x41) {
InitAllAddresses();
return;
}
uint8_t index = FindAddressIndex(addr);
FreeAddressByIndex(index);
};
};
#endif // __ADDRESS_H__

70
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_hexdump.h Normal file
View file

@ -0,0 +1,70 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_usb_h_) || defined(__HEXDUMP_H__)
#error "Never include UHS_hexdump.h directly; include UHS_Usb.h instead"
#else
#define __HEXDUMP_H__
extern int UsbDEBUGlvl;
template <class BASE_CLASS, class LEN_TYPE, class OFFSET_TYPE>
class HexDumper : public BASE_CLASS {
uint8_t byteCount;
OFFSET_TYPE byteTotal;
public:
HexDumper() : byteCount(0), byteTotal(0) {
};
void Initialize(void) {
byteCount = 0;
byteTotal = 0;
};
virtual void Parse(const LEN_TYPE len, const uint8_t *pbuf, const OFFSET_TYPE &offset);
};
template <class BASE_CLASS, class LEN_TYPE, class OFFSET_TYPE>
void HexDumper<BASE_CLASS, LEN_TYPE, OFFSET_TYPE>::Parse(const LEN_TYPE len, const uint8_t *pbuf, const OFFSET_TYPE &offset) {
if(UsbDEBUGlvl >= 0x80) { // Fully bypass this block of code if we do not debug.
for(LEN_TYPE j = 0; j < len; j++, byteCount++, byteTotal++) {
if(!byteCount) {
PrintHex<OFFSET_TYPE > (byteTotal, 0x80);
E_Notify(PSTR(": "), 0x80);
}
PrintHex<uint8_t > (pbuf[j], 0x80);
E_Notify(PSTR(" "), 0x80);
if(byteCount == 15) {
E_Notify(PSTR("\r\n"), 0x80);
byteCount = 0xFF;
}
}
}
}
#endif // __HEXDUMP_H__

111
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_host.h Normal file
View file

@ -0,0 +1,111 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
/* USB functions */
#ifndef _UHS_host_h_
#define _UHS_host_h_
// WARNING: Do not change the order of includes, or stuff will break!
#include <inttypes.h>
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#if DISABLED(USE_UHS3_USB)
#include <ISR_safe_memory.h>
#include <Wire.h>
#include <SPI.h>
#include <UHS_ByteBuffer.h>
#endif
#include "UHS_macros.h"
// None of these should ever be directly included by a driver, or a user's sketch.
#include "../dyn_SWI/dyn_SWI.h"
#include "UHS_USB_IDs.h"
#include "UHS_settings.h"
#include "UHS_usb_ch9.h"
#include "UHS_UsbCore.h"
#include "UHS_address.h"
#include "UHS_usbhost.h"
#include "UHS_printhex.h"
#include "UHS_message.h"
// Load system components as required
#if defined(LOAD_USB_HOST_SYSTEM) && !defined(USB_HOST_SYSTEM_LOADED)
#include "UHS_util_INLINE.h"
#include "UHS_host_INLINE.h"
#include "UHS_printf_HELPER.h"
#if defined(LOAD_USB_HOST_SHIELD)
#include "USB_HOST_SHIELD/USB_HOST_SHIELD.h"
#endif
#if defined(LOAD_UHS_KINETIS_FS_HOST) && !defined(UHS_KINETIS_FS_HOST_LOADED)
#include "UHS_KINETIS_FS_HOST/UHS_KINETIS_FS_HOST.h"
#endif
#if defined(LOAD_UHS_KINETIS_EHCI) && !defined(UHS_KINETIS_EHCI_LOADED)
#include "UHS_KINETIS_EHCI/UHS_KINETIS_EHCI.h"
#endif
// Load USB drivers and multiplexers
#if defined(LOAD_UHS_HUB)
#include "UHS_HUB/UHS_HUB.h"
#endif // HUB loaded
#if defined(LOAD_UHS_BULK_STORAGE)
#include "UHS_BULK_STORAGE/UHS_BULK_STORAGE.h"
#endif
#if defined(LOAD_GENERIC_STORAGE)
#include "../UHS_FS/UHS_FS.h"
#endif
// Add BT and optionally HID if directed to do so
#if defined(LOAD_UHS_BT)
#include "UHS_BT/UHS_BT.h"
#endif // BT and optionally HID loaded
// Add HID
#if defined(LOAD_UHS_HID)
#include "UHS_HID/UHS_HID.h"
#endif // HID loaded
// Add CDC multiplexers (currently only ACM)
#if defined(LOAD_UHS_CDC_ACM) || defined(LOAD_UHS_CDC_ACM_FTDI) || defined(LOAD_UHS_CDC_ACM_PROLIFIC) || defined(LOAD_UHS_CDC_ACM_XR21B1411)
#include "UHS_CDC/UHS_CDC.h"
#endif // CDC loaded
#if defined(LOAD_UHS_ADK)
#include "UHS_ADK/UHS_ADK.h"
#endif
#if defined(LOAD_UHS_MIDI)
#include "UHS_MIDI/UHS_MIDI.h"
#endif
#endif // System code loaded
#endif // _UHS_host_h_

1224
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_host_INLINE.h Normal file
View file

@ -0,0 +1,1224 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if defined(LOAD_USB_HOST_SYSTEM) && !defined(USB_HOST_SYSTEM_LOADED)
#define USB_HOST_SYSTEM_LOADED
#ifndef DEBUG_PRINTF_EXTRA_HUGE_UHS_HOST
#define DEBUG_PRINTF_EXTRA_HUGE_UHS_HOST 0
#endif
#if DEBUG_PRINTF_EXTRA_HUGE
#if DEBUG_PRINTF_EXTRA_HUGE_UHS_HOST
#define HOST_DEBUG(...) printf(__VA_ARGS__)
#else
#define HOST_DEBUG(...) VOID0
#endif
#else
#define HOST_DEBUG(...) VOID0
#endif
UHS_EpInfo* UHS_USB_HOST_BASE::getEpInfoEntry(uint8_t addr, uint8_t ep) {
UHS_Device *p = addrPool.GetUsbDevicePtr(addr);
if(!p || !p->epinfo)
return NULL;
UHS_EpInfo *pep;
for(uint8_t j = 0; j < UHS_HOST_MAX_INTERFACE_DRIVERS; j++) {
pep = (UHS_EpInfo *)(p->epinfo[j]);
for(uint8_t i = 0; i < p->epcount; i++) {
if((pep)->epAddr == ep) {
HOST_DEBUG("ep entry for interface %d ep %d max packet size = %d\r\n", pep->bIface, ep, pep->maxPktSize);
return pep;
}
pep++;
}
}
return NULL;
}
/**
* Sets a device table entry for a device.
* Each device is different and has different number of endpoints.
* This function plugs endpoint record structure, defined in application, to devtable
*
* @param addr device address
* @param epcount how many endpoints
* @param eprecord pointer to the endpoint structure
* @return Zero for success, or error code
*/
uint8_t UHS_USB_HOST_BASE::setEpInfoEntry(uint8_t addr, uint8_t iface, uint8_t epcount, volatile UHS_EpInfo* eprecord) {
if(!eprecord)
return UHS_HOST_ERROR_BAD_ARGUMENT;
UHS_Device *p = addrPool.GetUsbDevicePtr(addr);
if(!p)
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
p->address.devAddress = addr;
p->epinfo[iface] = eprecord;
p->epcount = epcount;
return 0;
}
/**
* sets all enpoint addresses to zero.
* Sets all max packet sizes to defaults
* Clears all endpoint attributes
* Sets bmNakPower to USB_NAK_DEFAULT
* Sets binterface to zero.
* Sets bNumEP to zero.
* Sets bAddress to zero.
* Clears qNextPollTime and sets bPollEnable to false.
*
* @param maxep How many endpoints to initialize
* @param device pointer to the device driver instance (this)
*
*/
void UHS_USB_HOST_BASE::DeviceDefaults(uint8_t maxep, UHS_USBInterface *interface) {
for(uint8_t i = 0; i < maxep; i++) {
interface->epInfo[i].epAddr = 0;
interface->epInfo[i].maxPktSize = (i) ? 0 : 8;
interface->epInfo[i].epAttribs = 0;
interface->epInfo[i].bmNakPower = UHS_USB_NAK_DEFAULT;
}
interface->pUsb->GetAddressPool()->FreeAddress(interface->bAddress);
interface->bIface = 0;
interface->bNumEP = 1;
interface->bAddress = 0;
interface->qNextPollTime = 0;
interface->bPollEnable = false;
}
/**
* Perform a bus reset to the port of the connected device
*
* @param parent index to Parent
* @param port what port on the parent
* @param address address of the device
* @return Zero for success, or error code
*/
uint8_t UHS_USB_HOST_BASE::doSoftReset(uint8_t parent, uint8_t port, uint8_t address) {
uint8_t rcode = 0;
if(parent == 0) {
// Send a bus reset on the root interface.
doHostReset();
} else {
// reset parent port
devConfig[parent]->ResetHubPort(port);
}
//
// Many devices require a delay before setting the address here...
// We loop upon fails for up to 2 seconds instead.
// Most devices will be happy without a retry.
//
uint8_t retries = 0;
if(address) {
do {
rcode = setAddr(0, address);
if(!rcode) break;
retries++;
sof_delay(10);
} while(retries < 200);
HOST_DEBUG("%i retries.\r\n", retries);
} else {
#if DEBUG_PRINTF_EXTRA_HUGE
printf("\r\ndoSoftReset called with address == 0.\r\n");
#endif
}
return rcode;
}
/*
* Pseudo code so you may understand the code flow.
*
* reset; (happens at the lower level)
* GetDevDescr();
* reset;
* If there are no configuration descriptors {
* //
* // Note: I know of no device that does this.
* // I suppose there could be one though.
* //
* try to enumerate.
* } else {
* last success count = 0
* best config = 0
* for each configuration descriptor {
* for each interface descriptor {
* get the endpoint descriptors for this interface.
* Check to see if a driver can handle this interface.
* If it can, add 1 to the success count.
* }
* if success count > last success count {
* best config = current config
* last success count = success count
* }
* }
* set the device config to the best config
* for each best config interface descriptor {
* initialize driver that can handle this interface config
* }
* }
*
* NOTES:
* 1: We do not need to save toggle states anymore and have not
* needed to for some time, because the lower level driver
* actually corrects wrong toggles on-the-fly for us.
*
* 2: We always do a second reset, since this stupid bug is
* actually part of the specification documents that I
* have found all over the net. Even Linux does it, and
* many devices actually EXPECT this behavior. Some devices
* will not enumerate without it. For devices that do not
* need it, the additional reset is harmless. Here is an
* example of one of these documents, see page Five:
* http://www.ftdichip.com/Support/Documents/TechnicalNotes/TN_113_Simplified%20Description%20of%20USB%20Device%20Enumeration.pdf
*
*
*/
/**
* Enumerates interfaces on devices
*
* @param parent index to Parent
* @param port what port on the parent
* @param speed the speed of the device
* @return Zero for success, or error code
*/
uint8_t UHS_USB_HOST_BASE::Configuring(uint8_t parent, uint8_t port, uint8_t speed) {
//uint8_t bAddress = 0;
HOST_DEBUG("\r\n\r\n\r\nConfiguring: parent = %i, port = %i, speed = %i\r\n", parent, port, speed);
uint8_t rcode = 0;
uint8_t retries = 0;
uint8_t numinf = 0;
uint8_t configs;
UHS_Device *p = NULL;
//EpInfo epInfo; // cap at 16, this should be fairly reasonable.
ENUMERATION_INFO ei;
uint8_t bestconf = 0;
uint8_t bestsuccess = 0;
uint8_t devConfigIndex;
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
const uint8_t biggest = 0x40;
// wrap in {} to throw away the 64 byte buffer when we are done with it
{
uint8_t buf[biggest];
USB_DEVICE_DESCRIPTOR *udd = reinterpret_cast<USB_DEVICE_DESCRIPTOR *>(buf);
#else
const uint8_t biggest = 18;
uint8_t buf[biggest];
USB_DEVICE_DESCRIPTOR *udd = reinterpret_cast<USB_DEVICE_DESCRIPTOR *>(buf);
USB_CONFIGURATION_DESCRIPTOR *ucd = reinterpret_cast<USB_CONFIGURATION_DESCRIPTOR *>(buf);
#endif
//for(devConfigIndex = 0; devConfigIndex < UHS_HOST_MAX_INTERFACE_DRIVERS; devConfigIndex++) {
// if((devConfig[devConfigIndex]->bAddress) && (!devConfig[devConfigIndex]->bPollEnable)) {
// devConfig[devConfigIndex]->bAddress = 0;
// }
//}
// Serial.print("HOST USB Host @ 0x");
// Serial.println((uint32_t)this, HEX);
// Serial.print("HOST USB Host Address Pool @ 0x");
// Serial.println((uint32_t)GetAddressPool(), HEX);
sof_delay(200);
p = addrPool.GetUsbDevicePtr(0);
if(!p) {
HOST_DEBUG("Configuring error: USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL\r\n");
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
}
p->speed = speed;
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
p->epinfo[0][0].maxPktSize = 0x40; // Windows bug is expected.
// poison data
// udd->bMaxPacketSize0 = 0U;
#else
p->epinfo[0][0].maxPktSize = 0x08; // USB Spec, start small, work your way up.
#endif
again:
memset((void *)buf, 0, biggest);
HOST_DEBUG("\r\n\r\nConfiguring PktSize 0x%2.2x, rcode: 0x%2.2x, retries %i,\r\n", p->epinfo[0][0].maxPktSize, rcode, retries);
rcode = getDevDescr(0, biggest, (uint8_t*)buf);
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
if(rcode || udd->bMaxPacketSize0 < 8)
#else
if(rcode)
#endif
{
if(rcode == UHS_HOST_ERROR_JERR && retries < 4) {
//
// Some devices return JERR when plugged in.
// Attempts to reinitialize the device usually works.
//
// I have a hub that will refuse to work and acts like
// this unless external power is supplied.
// So this may not always work, and you may be fooled.
//
sof_delay(100);
retries++;
goto again;
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
} else if(((rcode == UHS_HOST_ERROR_DMA || rcode == UHS_HOST_ERROR_MEM_LAT) && retries < 4) || (udd->bMaxPacketSize0 < 8 && !rcode)) {
if(p->epinfo[0][0].maxPktSize > 8 && rcode == UHS_HOST_ERROR_DMA) p->epinfo[0][0].maxPktSize = p->epinfo[0][0].maxPktSize >> 1;
#else
} else if((rcode == UHS_HOST_ERROR_DMA || rcode == UHS_HOST_ERROR_MEM_LAT) && retries < 4) {
if(p->epinfo[0][0].maxPktSize < 32) p->epinfo[0][0].maxPktSize = p->epinfo[0][0].maxPktSize << 1;
#endif
HOST_DEBUG("Configuring error: 0x%2.2x UHS_HOST_ERROR_DMA. Retry with maxPktSize: %i\r\n", rcode, p->epinfo[0][0].maxPktSize);
doSoftReset(parent, port, 0);
retries++;
sof_delay(200);
goto again;
}
HOST_DEBUG("Configuring error: 0x%2.2x Can't get USB_DEVICE_DESCRIPTOR\r\n", rcode);
return rcode;
}
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
ei.address = addrPool.AllocAddress(parent, false, port);
if(!ei.address) {
return UHS_HOST_ERROR_ADDRESS_POOL_FULL;
}
p = addrPool.GetUsbDevicePtr(ei.address);
// set to 1 if you suspect address table corruption.
#if 0
if(!p) {
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
}
#endif
p->speed = speed;
rcode = doSoftReset(parent, port, ei.address);
if(rcode) {
addrPool.FreeAddress(ei.address);
HOST_DEBUG("Configuring error: %2.2x Can't set USB INTERFACE ADDRESS\r\n", rcode);
return rcode;
}
{ // the { } wrapper saves on stack.
HOST_DEBUG("DevDescr 2nd poll, bMaxPacketSize0:%u\r\n", udd->bMaxPacketSize0);
UHS_EpInfo dev1ep;
dev1ep.maxPktSize = udd->bMaxPacketSize0;
dev1ep.epAddr = 0;
dev1ep.epAttribs = 0;
dev1ep.bmNakPower = UHS_USB_NAK_MAX_POWER;
p->address.devAddress = ei.address;
p->epcount = 1;
p->epinfo[0] = &dev1ep;
sof_delay(10);
memset((void *)buf, 0, biggest);
rcode = getDevDescr(ei.address, 18, (uint8_t*)buf);
if(rcode) HOST_DEBUG("getDevDescr err: 0x%x \r\n", rcode);
addrPool.FreeAddress(ei.address);
if(rcode && rcode != UHS_HOST_ERROR_DMA) {
return rcode;
}
sof_delay(10);
}
#endif
ei.vid = udd->idVendor;
ei.pid = udd->idProduct;
ei.bcdDevice = udd->bcdDevice;
ei.klass = udd->bDeviceClass;
ei.subklass = udd->bDeviceSubClass;
ei.protocol = udd->bDeviceProtocol;
ei.bMaxPacketSize0 = udd->bMaxPacketSize0;
ei.currentconfig = 0;
ei.parent = parent;
ei.port = port;
configs = udd->bNumConfigurations;
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
} // unwrapped, old large buf now invalid and discarded.
uint8_t buf[18];
USB_CONFIGURATION_DESCRIPTOR *ucd = reinterpret_cast<USB_CONFIGURATION_DESCRIPTOR *>(buf);
#endif
ei.address = addrPool.AllocAddress(parent, IsHub(ei.klass), port);
if(!ei.address) {
return UHS_HOST_ERROR_ADDRESS_POOL_FULL;
}
p = addrPool.GetUsbDevicePtr(ei.address);
// set to 1 if you suspect address table corruption.
#if 0
if(!p) {
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
}
#endif
p->speed = speed;
rcode = doSoftReset(parent, port, ei.address);
if(rcode) {
addrPool.FreeAddress(ei.address);
HOST_DEBUG("Configuring error: %2.2x Can't set USB INTERFACE ADDRESS\r\n", rcode);
return rcode;
}
if(configs < 1) {
HOST_DEBUG("No interfaces?!\r\n");
addrPool.FreeAddress(ei.address);
// rcode = TestInterface(&ei);
// Not implemented (yet)
rcode = UHS_HOST_ERROR_DEVICE_NOT_SUPPORTED;
} else {
HOST_DEBUG("configs: %i\r\n", configs);
for(uint8_t conf = 0; (!rcode) && (conf < configs); conf++) {
// read the config descriptor into a buffer.
rcode = getConfDescr(ei.address, sizeof (USB_CONFIGURATION_DESCRIPTOR), conf, buf);
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't get USB_INTERFACE_DESCRIPTOR\r\n", rcode);
rcode = UHS_HOST_ERROR_FailGetConfDescr;
continue;
}
ei.currentconfig = conf;
numinf = ucd->bNumInterfaces; // Does _not_ include alternates!
HOST_DEBUG("CONFIGURATION: %i, bNumInterfaces %i, wTotalLength %i\r\n", conf, numinf, ucd->wTotalLength);
uint8_t success = 0;
uint16_t inf = 0;
uint8_t data[ei.bMaxPacketSize0];
UHS_EpInfo *pep;
pep = ctrlReqOpen(ei.address, mkSETUP_PKT8(UHS_bmREQ_GET_DESCR, USB_REQUEST_GET_DESCRIPTOR, ei.currentconfig, USB_DESCRIPTOR_CONFIGURATION, 0x0000U, ucd->wTotalLength), data);
if(!pep) {
rcode = UHS_HOST_ERROR_NULL_EPINFO;
continue;
}
uint16_t left;
uint16_t read;
uint8_t offset;
rcode = initDescrStream(&ei, ucd, pep, data, &left, &read, &offset);
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't get USB_INTERFACE_DESCRIPTOR stream.\r\n", rcode);
break;
}
for(; (numinf) && (!rcode); inf++) {
// iterate for each interface on this config
rcode = getNextInterface(&ei, pep, data, &left, &read, &offset);
if(rcode == UHS_HOST_ERROR_END_OF_STREAM) {
HOST_DEBUG("USB_INTERFACE END OF STREAM\r\n");
ctrlReqClose(pep, UHS_bmREQ_GET_DESCR, left, ei.bMaxPacketSize0, data);
rcode = 0;
break;
}
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't close USB_INTERFACE_DESCRIPTOR stream.\r\n", rcode);
continue;
}
rcode = TestInterface(&ei);
if(!rcode) success++;
rcode = 0;
}
if(!inf) {
rcode = TestInterface(&ei);
if(!rcode) success++;
rcode = 0;
}
if(success > bestsuccess) {
bestconf = conf;
bestsuccess = success;
}
}
if(!bestsuccess) rcode = UHS_HOST_ERROR_DEVICE_NOT_SUPPORTED;
}
if(!rcode) {
rcode = getConfDescr(ei.address, sizeof (USB_CONFIGURATION_DESCRIPTOR), bestconf, buf);
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't get USB_INTERFACE_DESCRIPTOR\r\n", rcode);
rcode = UHS_HOST_ERROR_FailGetConfDescr;
}
}
if(!rcode) {
bestconf++;
ei.currentconfig = bestconf;
numinf = ucd->bNumInterfaces; // Does _not_ include alternates!
HOST_DEBUG("CONFIGURATION: %i, bNumInterfaces %i, wTotalLength %i\r\n", bestconf, numinf, ucd->wTotalLength);
if(!rcode) {
HOST_DEBUG("Best configuration is %i, enumerating interfaces.\r\n", bestconf);
uint16_t inf = 0;
uint8_t data[ei.bMaxPacketSize0];
UHS_EpInfo *pep;
pep = ctrlReqOpen(ei.address, mkSETUP_PKT8(UHS_bmREQ_GET_DESCR, USB_REQUEST_GET_DESCRIPTOR, ei.currentconfig - 1, USB_DESCRIPTOR_CONFIGURATION, 0x0000U, ucd->wTotalLength), data);
if(!pep) {
rcode = UHS_HOST_ERROR_NULL_EPINFO;
} else {
uint16_t left;
uint16_t read;
uint8_t offset;
rcode = initDescrStream(&ei, ucd, pep, data, &left, &read, &offset);
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't get USB_INTERFACE_DESCRIPTOR stream.\r\n", rcode);
} else {
for(; (numinf) && (!rcode); inf++) {
// iterate for each interface on this config
rcode = getNextInterface(&ei, pep, data, &left, &read, &offset);
if(rcode == UHS_HOST_ERROR_END_OF_STREAM) {
ctrlReqClose(pep, UHS_bmREQ_GET_DESCR, left, ei.bMaxPacketSize0, data);
rcode = 0;
break;
}
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't close USB_INTERFACE_DESCRIPTOR stream.\r\n", rcode);
continue;
}
if(enumerateInterface(&ei) == UHS_HOST_MAX_INTERFACE_DRIVERS) {
HOST_DEBUG("No interface driver for this interface.");
} else {
HOST_DEBUG("Interface Configured\r\n");
}
}
}
}
} else {
HOST_DEBUG("Configuring error: %2.2x Can't set USB_INTERFACE_CONFIG stream.\r\n", rcode);
}
}
if(!rcode) {
rcode = setConf(ei.address, bestconf);
if(rcode) {
HOST_DEBUG("Configuring error: %2.2x Can't set Configuration.\r\n", rcode);
addrPool.FreeAddress(ei.address);
} else {
for(devConfigIndex = 0; devConfigIndex < UHS_HOST_MAX_INTERFACE_DRIVERS; devConfigIndex++) {
HOST_DEBUG("Driver %i ", devConfigIndex);
if(!devConfig[devConfigIndex]) {
HOST_DEBUG("no driver at this index.\r\n");
continue; // no driver
}
HOST_DEBUG("@ %2.2x ", devConfig[devConfigIndex]->bAddress);
if(devConfig[devConfigIndex]->bAddress) {
if(!devConfig[devConfigIndex]->bPollEnable) {
HOST_DEBUG("Initialize\r\n");
rcode = devConfig[devConfigIndex]->Finalize();
rcode = devConfig[devConfigIndex]->Start();
if(!rcode) {
HOST_DEBUG("Total endpoints = (%i)%i\r\n", p->epcount, devConfig[devConfigIndex]->bNumEP);
} else {
break;
}
} else {
HOST_DEBUG("Already initialized.\r\n");
continue; // consumed
}
} else {
HOST_DEBUG("Skipped\r\n");
}
}
#if 0 // defined(UHS_HID_LOADED)
// Now do HID
#endif
}
} else {
addrPool.FreeAddress(ei.address);
}
return rcode;
}
/**
* Removes a device from the tables
*
* @param addr address of the device
* @return nothing
*/
void UHS_USB_HOST_BASE::ReleaseDevice(uint8_t addr) {
if(addr) {
#if 0 // defined(UHS_HID_LOADED)
// Release any HID children
UHS_HID_Release(this, addr);
#endif
for(uint8_t i = 0; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) {
if(!devConfig[i]) continue;
if(devConfig[i]->bAddress == addr) {
devConfig[i]->Release();
break;
}
}
}
}
/**
* Gets the device descriptor, or part of it from endpoint Zero.
*
* @param addr Address of the device
* @param nbytes how many bytes to return
* @param dataptr pointer to the data to return
* @return status of the request, zero is success.
*/
uint8_t UHS_USB_HOST_BASE::getDevDescr(uint8_t addr, uint16_t nbytes, uint8_t* dataptr) {
return ( ctrlReq(addr, mkSETUP_PKT8(UHS_bmREQ_GET_DESCR, USB_REQUEST_GET_DESCRIPTOR, 0x00, USB_DESCRIPTOR_DEVICE, 0x0000, nbytes), nbytes, dataptr));
}
/**
* Gets the config descriptor, or part of it from endpoint Zero.
*
* @param addr Address of the device
* @param nbytes how many bytes to return
* @param conf index to descriptor to return
* @param dataptr ointer to the data to return
* @return status of the request, zero is success.
*/
uint8_t UHS_USB_HOST_BASE::getConfDescr(uint8_t addr, uint16_t nbytes, uint8_t conf, uint8_t* dataptr) {
return ( ctrlReq(addr, mkSETUP_PKT8(UHS_bmREQ_GET_DESCR, USB_REQUEST_GET_DESCRIPTOR, conf, USB_DESCRIPTOR_CONFIGURATION, 0x0000, nbytes), nbytes, dataptr));
}
/**
* Get the string descriptor from a device
*
* @param addr Address of the device
* @param ns
* @param index
* @param langid language ID
* @param dataptr pointer to the data to return
* @return status of the request, zero is success.
*/
uint8_t UHS_USB_HOST_BASE::getStrDescr(uint8_t addr, uint16_t ns, uint8_t index, uint16_t langid, uint8_t* dataptr) {
return ( ctrlReq(addr, mkSETUP_PKT8(UHS_bmREQ_GET_DESCR, USB_REQUEST_GET_DESCRIPTOR, index, USB_DESCRIPTOR_STRING, langid, ns), ns, dataptr));
}
//
//set address
//
/**
* Set the address of a device to a new address via endpoint Zero.
*
* @param oldaddr current address
* @param newaddr new address
* @return status of the request, zero is success.
*/
uint8_t UHS_USB_HOST_BASE::setAddr(uint8_t oldaddr, uint8_t newaddr) {
uint8_t rcode = ctrlReq(oldaddr, mkSETUP_PKT8(UHS_bmREQ_SET, USB_REQUEST_SET_ADDRESS, newaddr, 0x00, 0x0000, 0x0000), 0x0000, NULL);
sof_delay(300); // Older spec says you should wait at least 200ms
return rcode;
}
//
//set configuration
//
/**
* Set the configuration for the device to use via endpoint Zero.
*
* @param addr Address of the device
* @param conf_value configuration index value
* @return status of the request, zero is success.
*/
uint8_t UHS_USB_HOST_BASE::setConf(uint8_t addr, uint8_t conf_value) {
return ( ctrlReq(addr, mkSETUP_PKT8(UHS_bmREQ_SET, USB_REQUEST_SET_CONFIGURATION, conf_value, 0x00, 0x0000, 0x0000), 0x0000, NULL));
}
/* rcode 0 if no errors. rcode 01-0f is relayed from HRSL */
/**
* Writes data to an interface pipe
*
* @param addr Address of the device
* @param ep Endpoint of the pipe
* @param nbytes number of bytes to transfer
* @param data pointer to buffer to hold transfer
* @return zero for success or error code
*/
uint8_t UHS_USB_HOST_BASE::outTransfer(uint8_t addr, uint8_t ep, uint16_t nbytes, uint8_t* data) {
UHS_EpInfo *pep = NULL;
uint16_t nak_limit = 0;
HOST_DEBUG("outTransfer: addr: 0x%2.2x ep: 0x%2.2x nbytes: 0x%4.4x data: 0x%p\r\n", addr, ep, nbytes, data);
uint8_t rcode = SetAddress(addr, ep, &pep, nak_limit);
HOST_DEBUG("outTransfer: SetAddress 0x%2.2x\r\n", rcode);
if(!rcode)
rcode = OutTransfer(pep, nak_limit, nbytes, data);
return rcode;
};
/**
* Reads data from an interface pipe
*
* @param addr Address of the device
* @param ep Endpoint of the pipe
* @param nbytesptr number of bytes to transfer
* @param data pointer to buffer to hold transfer
* @return zero for success or error code
*/
uint8_t UHS_USB_HOST_BASE::inTransfer(uint8_t addr, uint8_t ep, uint16_t *nbytesptr, uint8_t* data) {
UHS_EpInfo *pep = NULL;
uint16_t nak_limit = 0;
uint8_t rcode = SetAddress(addr, ep, &pep, nak_limit);
// if(rcode) {
// USBTRACE3("(USB::InTransfer) SetAddress Failed ", rcode, 0x81);
// USBTRACE3("(USB::InTransfer) addr requested ", addr, 0x81);
// USBTRACE3("(USB::InTransfer) ep requested ", ep, 0x81);
// return rcode;
// }
if(!rcode)
rcode = InTransfer(pep, nak_limit, nbytesptr, data);
return rcode;
}
/**
* Initialize the descriptor stream, works much like opening a file.
*
* @param ei
* @param ucd
* @param pep
* @param data
* @param left
* @param read
* @param offset
* @return zero for success or error code
*/
uint8_t UHS_USB_HOST_BASE::initDescrStream(ENUMERATION_INFO *ei, USB_CONFIGURATION_DESCRIPTOR *ucd, UHS_EpInfo *pep, uint8_t *data, uint16_t *left, uint16_t *read, uint8_t *offset) {
if(!ei || !ucd) return UHS_HOST_ERROR_BAD_ARGUMENT;
if(!pep) return UHS_HOST_ERROR_NULL_EPINFO;
*left = ucd->wTotalLength;
*read = 0;
*offset = 1;
uint8_t rcode;
pep->maxPktSize = ei->bMaxPacketSize0;
rcode = getone(pep, left, read, data, offset);
return rcode;
}
uint8_t UHS_USB_HOST_BASE::getNextInterface(ENUMERATION_INFO *ei, UHS_EpInfo *pep, uint8_t data[], uint16_t *left, uint16_t *read, uint8_t *offset) {
uint16_t remain;
uint8_t ty;
uint8_t rcode = UHS_HOST_ERROR_END_OF_STREAM;
uint8_t *ptr;
uint8_t epc = 0;
ei->interface.numep = 0;
ei->interface.klass = 0;
ei->interface.subklass = 0;
ei->interface.protocol = 0;
while(*left + *read) {
remain = data[*offset]; // bLength
while(remain < 2) {
rcode = getone(pep, left, read, data, offset);
if(rcode)
return rcode;
remain = data[*offset];
}
rcode = getone(pep, left, read, data, offset);
if(rcode)
return rcode;
ty = data[*offset]; // bDescriptorType
HOST_DEBUG("bLength: %i ", remain);
HOST_DEBUG("bDescriptorType: %2.2x\r\n", ty);
remain--;
if(ty == USB_DESCRIPTOR_INTERFACE) {
HOST_DEBUG("INTERFACE DESCRIPTOR FOUND\r\n");
ptr = (uint8_t *)(&(ei->interface.bInterfaceNumber));
for(int i = 0; i < 6; i++) {
rcode = getone(pep, left, read, data, offset);
if(rcode)
return rcode;
*ptr = data[*offset];
ptr++;
}
rcode = getone(pep, left, read, data, offset);
if(rcode)
return rcode;
// Now at iInterface
// Get endpoints.
HOST_DEBUG("Getting %i endpoints\r\n", ei->interface.numep);
while(epc < ei->interface.numep) {
rcode = getone(pep, left, read, data, offset);
if(rcode) {
HOST_DEBUG("ENDPOINT DESCRIPTOR DIED WAY EARLY\r\n");
return rcode;
}
remain = data[*offset]; // bLength
while(remain < 2) {
rcode = getone(pep, left, read, data, offset);
if(rcode)
return rcode;
remain = data[*offset];
}
rcode = getone(pep, left, read, data, offset);
if(rcode) {
HOST_DEBUG("ENDPOINT DESCRIPTOR DIED EARLY\r\n");
return rcode;
}
ty = data[*offset]; // bDescriptorType
HOST_DEBUG("bLength: %i ", remain);
HOST_DEBUG("bDescriptorType: %2.2x\r\n", ty);
remain -= 2;
if(ty == USB_DESCRIPTOR_ENDPOINT) {
HOST_DEBUG("ENDPOINT DESCRIPTOR: %i\r\n", epc);
ptr = (uint8_t *)(&(ei->interface.epInfo[epc].bEndpointAddress));
for(unsigned int i = 0; i< sizeof (ENDPOINT_INFO); i++) {
rcode = getone(pep, left, read, data, offset);
if(rcode) {
HOST_DEBUG("ENDPOINT DESCRIPTOR DIED LATE\r\n");
return rcode;
}
*ptr = data[*offset];
ptr++;
remain--;
}
epc++;
HOST_DEBUG("ENDPOINT DESCRIPTOR OK\r\n");
}
rcode = eat(pep, left, read, data, offset, &remain);
if(rcode) {
HOST_DEBUG("ENDPOINT DESCRIPTOR DIED EATING\r\n");
return rcode;
}
remain = 0;
}
remain = 1;
// queue ahead, but do not report if error.
rcode = eat(pep, left, read, data, offset, &remain);
if(!ei->interface.numep && rcode) {
return rcode;
}
HOST_DEBUG("ENDPOINT DESCRIPTORS FILLED\r\n");
return 0;
} else {
rcode = eat(pep, left, read, data, offset, &remain);
if(rcode)
return rcode;
}
rcode = UHS_HOST_ERROR_END_OF_STREAM;
}
return rcode;
}
uint8_t UHS_USB_HOST_BASE::seekInterface(ENUMERATION_INFO *ei, uint16_t inf, USB_CONFIGURATION_DESCRIPTOR *ucd) {
if(!ei || !ucd) return UHS_HOST_ERROR_BAD_ARGUMENT;
uint8_t data[ei->bMaxPacketSize0];
UHS_EpInfo *pep;
pep = ctrlReqOpen(ei->address, mkSETUP_PKT8(UHS_bmREQ_GET_DESCR, USB_REQUEST_GET_DESCRIPTOR, ei->currentconfig,
USB_DESCRIPTOR_CONFIGURATION, 0x0000U, ucd->wTotalLength), data);
if(!pep) return UHS_HOST_ERROR_NULL_EPINFO;
uint16_t left = ucd->wTotalLength;
uint8_t cinf = 0;
uint8_t ty;
uint8_t epc = 0;
uint16_t remain = ucd->bLength;
uint16_t read = 0;
uint8_t offset = remain;
uint8_t *ptr;
uint8_t rcode;
ei->interface.numep = 0;
ei->interface.klass = 0;
ei->interface.subklass = 0;
ei->interface.protocol = 0;
pep->maxPktSize = ei->bMaxPacketSize0;
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
HOST_DEBUG("\r\nGetting interface: %i\r\n", inf);
inf++;
while(cinf != inf && (left + read)) {
//HOST_DEBUG("getInterface: cinf: %i inf: %i left: %i read: %i offset: %i remain %i\r\n", cinf, inf, left, read, offset, remain);
// Go past current descriptor
HOST_DEBUG("Skip: %i\r\n", remain);
rcode = eat(pep, &left, &read, data, &offset, &remain);
if(rcode)
return rcode;
remain = data[offset]; // bLength
while(remain < 2) {
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
remain = data[offset];
}
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
ty = data[offset]; // bDescriptorType
HOST_DEBUG("bLength: %i ", remain);
HOST_DEBUG("bDescriptorType: %2.2x\r\n", ty);
remain--;
if(ty == USB_DESCRIPTOR_INTERFACE) {
HOST_DEBUG("INTERFACE DESCRIPTOR: %i\r\n", cinf);
cinf++;
if(cinf == inf) {
// Get the interface descriptor information.
ptr = (uint8_t *)(&(ei->interface.bInterfaceNumber));
for(int i = 0; i < 6; i++) {
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
*ptr = data[offset];
ptr++;
}
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
// Now at iInterface
remain = 0;
// Get endpoints.
HOST_DEBUG("Getting %i endpoints\r\n", ei->interface.numep);
while(epc < ei->interface.numep) {
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
remain = data[offset]; // bLength
while(remain < 2) {
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
remain = data[offset];
}
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
ty = data[offset]; // bDescriptorType
HOST_DEBUG("bLength: %i ", remain);
HOST_DEBUG("bDescriptorType: %2.2x\r\n", ty);
remain--;
if(ty == USB_DESCRIPTOR_ENDPOINT) {
HOST_DEBUG("ENDPOINT DESCRIPTOR: %i\r\n", epc);
ptr = (uint8_t *)(&(ei->interface.epInfo[epc].bEndpointAddress));
for(unsigned int i = 0; i< sizeof (ENDPOINT_INFO); i++) {
rcode = getone(pep, &left, &read, data, &offset);
if(rcode)
return rcode;
*ptr = data[offset];
ptr++;
}
epc++;
remain = 0;
} else {
rcode = eat(pep, &left, &read, data, &offset, &remain);
if(rcode)
return rcode;
remain = 0;
}
}
}
}
}
return ctrlReqClose(pep, UHS_bmREQ_GET_DESCR, left, ei->bMaxPacketSize0, data);
}
uint8_t UHS_USB_HOST_BASE::getone(UHS_EpInfo *pep, uint16_t *left, uint16_t *read, uint8_t *dataptr, uint8_t *offset) {
uint8_t rcode = 0;
*offset += 1;
if(*offset < *read) {
return 0;
} else if(*left > 0) {
// uint16_t num = *left;
uint16_t num = pep->maxPktSize;
if(num > *left) num = *left;
*offset = 0;
rcode = ctrlReqRead(pep, left, read, num, dataptr);
if(rcode == 0) {
if(*read == 0) {
rcode = UHS_HOST_ERROR_END_OF_STREAM;
} else if(*read < num) *left = 0;
}
} else {
rcode = UHS_HOST_ERROR_END_OF_STREAM;
}
return rcode;
}
uint8_t UHS_USB_HOST_BASE::eat(UHS_EpInfo *pep, uint16_t *left, uint16_t *read, uint8_t *dataptr, uint8_t *offset, uint16_t *yum) {
uint8_t rcode = 0;
HOST_DEBUG("eating %i\r\n", *yum);
while(*yum) {
*yum -= 1;
rcode = getone(pep, left, read, dataptr, offset);
if(rcode) break;
}
return rcode;
}
uint8_t UHS_USB_HOST_BASE::ctrlReq(uint8_t addr, uint64_t Request, uint16_t nbytes, uint8_t* dataptr) {
//bool direction = bmReqType & 0x80; //request direction, IN or OUT
uint8_t rcode = 0;
// Serial.println("");
UHS_EpInfo *pep = ctrlReqOpen(addr, Request, dataptr);
if(!pep) {
HOST_DEBUG("ctrlReq1: ERROR_NULL_EPINFO addr: %d\r\n", addr);
return UHS_HOST_ERROR_NULL_EPINFO;
}
uint8_t rt = (uint8_t)(Request & 0xFFU);
// Serial.println("Opened");
uint16_t left = (uint16_t)(Request >> 48) /*total*/;
if(dataptr != NULL) {
//data stage
if((rt & 0x80) == 0x80) {
//IN transfer
while(left) {
// Bytes read into buffer
uint16_t read = nbytes;
HOST_DEBUG("ctrlReq2: left: %i, read:%i, nbytes %i\r\n", left, read, nbytes);
rcode = ctrlReqRead(pep, &left, &read, nbytes, dataptr);
#if UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE
HOST_DEBUG("RESULT: 0x%2.2x 0x%2.2x 0x%2.2x 0x%8.8lx%8.8lx\r\n", rcode, addr, read, (uint32_t)((Request>>32)&0xfffffffflu), (uint32_t)(Request&0xfffffffflu));
// Should only be used for GET_DESCRIPTOR USB_DESCRIPTOR_DEVICE
constexpr uint32_t req_match = ((uint32_t)USB_DESCRIPTOR_DEVICE << 24) |
((uint32_t)USB_REQUEST_GET_DESCRIPTOR << 8);
const uint32_t req_found = Request & 0xFF00FF00ul;
if(!addr && read && (req_found == req_match)) {
HOST_DEBUG("ctrlReq3: acceptBuffer sz %i nbytes %i left %i\n\r", read, nbytes, left);
left = 0;
rcode = UHS_HOST_ERROR_NONE;
break;
}
#endif
if(rcode) {
return rcode;
}
}
} else {
// OUT transfer
rcode = OutTransfer(pep, 0, nbytes, dataptr);
}
if(rcode) {
//return error
return ( rcode);
}
}
// Serial.println("Close Phase");
// Serial.flush();
// Status stage
rcode = ctrlReqClose(pep, rt, left, nbytes, dataptr);
// Serial.println("Closed");
return rcode;
}
uint8_t UHS_USB_HOST_BASE::EPClearHalt(uint8_t addr, uint8_t ep) {
return ctrlReq(addr, mkSETUP_PKT8(USB_SETUP_HOST_TO_DEVICE | USB_SETUP_TYPE_STANDARD | USB_SETUP_RECIPIENT_ENDPOINT, USB_REQUEST_CLEAR_FEATURE, USB_FEATURE_ENDPOINT_HALT, 0, ep, 0), 0, NULL);
}
uint8_t UHS_USB_HOST_BASE::TestInterface(ENUMERATION_INFO *ei) {
uint8_t devConfigIndex;
uint8_t rcode = 0;
HOST_DEBUG("TestInterface VID:%4.4x PID:%4.4x Class:%2.2x Subclass:%2.2x Protocol %2.2x\r\n", ei->vid, ei->pid, ei->klass, ei->subklass, ei->protocol);
HOST_DEBUG("Interface data: Class:%2.2x Subclass:%2.2x Protocol %2.2x, number of endpoints %i\r\n", ei->interface.klass, ei->interface.subklass, ei->interface.subklass, ei->interface.numep);
HOST_DEBUG("Parent: %2.2x, bAddress: %2.2x\r\n", ei->parent, ei->address);
for(devConfigIndex = 0; devConfigIndex < UHS_HOST_MAX_INTERFACE_DRIVERS; devConfigIndex++) {
if(!devConfig[devConfigIndex]) {
HOST_DEBUG("No driver at index %i\r\n", devConfigIndex);
continue; // no driver
}
if(devConfig[devConfigIndex]->bAddress) {
HOST_DEBUG("Driver %i is already consumed @ %2.2x\r\n", devConfigIndex, devConfig[devConfigIndex]->bAddress);
continue; // consumed
}
if(devConfig[devConfigIndex]->OKtoEnumerate(ei)) {
HOST_DEBUG("Driver %i supports this interface\r\n", devConfigIndex);
break;
}
}
if(devConfigIndex == UHS_HOST_MAX_INTERFACE_DRIVERS) {
rcode = UHS_HOST_ERROR_DEVICE_NOT_SUPPORTED;
#if 0 // defined(UHS_HID_LOADED)
// Check HID here, if it is, then lie
if(ei->klass == UHS_USB_CLASS_HID) {
devConfigIndex = UHS_HID_INDEX; // for debugging, otherwise this has no use.
rcode = 0;
}
#endif
}
if(!rcode) HOST_DEBUG("Driver %i can be used for this interface\r\n", devConfigIndex);
else HOST_DEBUG("No driver for this interface.\r\n");
return rcode;
};
uint8_t UHS_USB_HOST_BASE::enumerateInterface(ENUMERATION_INFO *ei) {
uint8_t devConfigIndex;
HOST_DEBUG("AttemptConfig: parent = %i, port = %i\r\n", ei->parent, ei->port);
#if 0 // defined(UHS_HID_LOADED)
// Check HID here, if it is, then lie
if(ei->klass == UHS_USB_CLASS_HID || ei->interface.klass == UHS_USB_CLASS_HID) {
UHS_HID_SetUSBInterface(this, ENUMERATION_INFO * ei);
devConfigIndex = UHS_HID_INDEX;
} else
#endif
for(devConfigIndex = 0; devConfigIndex < UHS_HOST_MAX_INTERFACE_DRIVERS; devConfigIndex++) {
if(!devConfig[devConfigIndex]) {
HOST_DEBUG("No driver at index %i\r\n", devConfigIndex);
continue; // no driver
}
if(devConfig[devConfigIndex]->bAddress) {
HOST_DEBUG("Driver %i is already consumed @ %2.2x\r\n", devConfigIndex, devConfig[devConfigIndex]->bAddress);
continue; // consumed
}
if(devConfig[devConfigIndex]->OKtoEnumerate(ei)) {
HOST_DEBUG("Driver %i supports this interface\r\n", devConfigIndex);
if(!devConfig[devConfigIndex]->SetInterface(ei)) break;
else devConfigIndex = UHS_HOST_MAX_INTERFACE_DRIVERS;
}
}
return devConfigIndex;
};
////////////////////////////////////////////////////////////////////////////////
// Vendor Specific Interface Class
////////////////////////////////////////////////////////////////////////////////
#if 0
/**
* Might go away, depends on if it is useful, or not.
*
* @param ei Enumeration information
* @return true if this interface driver can handle this interface description
*/
bool UHS_NI UHS_VSI::OKtoEnumerate(ENUMERATION_INFO *ei) {
return (
(ei->subklass == UHS_USB_CLASS_VENDOR_SPECIFIC) ||
(ei->interface.subklass == UHS_USB_CLASS_VENDOR_SPECIFIC)
);
}
/**
* Copy the entire ENUMERATION_INFO structure
* @param ei Enumeration information
* @return 0
*/
uint8_t UHS_NI UHS_VSI::SetInterface(ENUMERATION_INFO *ei) {
bNumEP = 1;
bAddress = ei->address;
eInfo.address = ei->address;
eInfo.bMaxPacketSize0 = ei->bMaxPacketSize0;
eInfo.currentconfig = ei->currentconfig;
eInfo.interface.bAlternateSetting = ei->interface.bAlternateSetting;
eInfo.interface.bInterfaceNumber = ei->interface.bInterfaceNumber;
eInfo.interface.numep = ei->interface.numep;
eInfo.interface.protocol = ei->interface.protocol;
eInfo.interface.subklass = ei->interface.subklass;
eInfo.klass = ei->klass;
eInfo.parent = ei->parent;
eInfo.pid = ei->pid;
eInfo.port = ei->port;
eInfo.protocol = ei->protocol;
eInfo.subklass = ei->subklass;
eInfo.vid = ei->vid;
for(uint8_t i = 0; i < eInfo.interface.numep; i++) {
eInfo.interface.epInfo[i].bEndpointAddress = ei->interface.epInfo[i].bEndpointAddress;
eInfo.interface.epInfo[i].bInterval = ei->interface.epInfo[i].bInterval;
eInfo.interface.epInfo[i].bmAttributes = ei->interface.epInfo[i].bmAttributes;
eInfo.interface.epInfo[i].wMaxPacketSize = ei->interface.epInfo[i].wMaxPacketSize;
}
return 0;
}
#endif
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#if 0
/* TO-DO: Move this silliness to a NONE driver.
* When we have a generic NONE driver we can:
* o Extract ALL device information to help users with a new device.
* o Use an unknown device from a sketch, kind of like usblib does.
* This will aid in making more drivers in a faster way.
*/
uint8_t UHS_USB_HOST_BASE::DefaultAddressing(uint8_t parent, uint8_t port, uint8_t speed) {
uint8_t rcode;
UHS_Device *p0 = NULL, *p = NULL;
// Get pointer to pseudo device with address 0 assigned
p0 = addrPool.GetUsbDevicePtr(0);
if(!p0)
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
if(!p0->epinfo)
return UHS_HOST_ERROR_NULL_EPINFO;
p0->speed = speed;
// Allocate new address according to device class
uint8_t bAddress = addrPool.AllocAddress(parent, false, port);
if(!bAddress)
return UHS_HOST_ERROR_ADDRESS_POOL_FULL;
p = addrPool.GetUsbDevicePtr(bAddress);
if(!p)
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
p->speed = speed;
// Assign new address to the device
rcode = setAddr(0, bAddress);
if(rcode) {
addrPool.FreeAddress(bAddress);
bAddress = 0;
return rcode;
}
return 0;
}
#endif
#else
#error "Never include UHS_host_INLINE.h, include UHS_host.h instead"
#endif

393
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_macros.h Normal file
View file

@ -0,0 +1,393 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(MACROS_H)
#define MACROS_H
#include "macro_logic.h"
/*
* Universal Arduino(tm) "IDE" fixups.
*/
// Just in case...
#ifndef SERIAL_PORT_MONITOR
#define SERIAL_PORT_MONITOR Serial
#endif
#ifndef INT16_MIN
#define INT16_MIN -32768
#endif
// require 10607+
#if defined(ARDUINO) && ARDUINO >=10607
// nop :-)
#else
#error "Arduino version too old, and must be at least 1.6.7"
#endif
// Nuke screwed up macro junk from the IDE.
#ifdef __cplusplus
#if defined(true)
#undef true
#endif
#if defined(false)
#undef false
#endif
#endif
#if !defined(UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE)
#if !defined(UHS_BIG_FLASH)
#if defined(FLASHEND) && defined(FLASHSTART)
#if (FLASHEND - FLASHSTART) > 0x0FFFFU
#define UHS_BIG_FLASH 1
#else
#define UHS_BIG_FLASH 0
#endif
#elif defined(__PIC32_FLASH_SIZE)
#if __PIC32_FLASH_SIZE > 511
#define UHS_BIG_FLASH 1
#else
#define UHS_BIG_FLASH 0
#endif
#elif defined(FLASHEND) && !defined(FLASHSTART)
// Assumes flash starts at 0x00000, is this a safe assumption?
// 192K + should be OK
#if FLASHEND > 0x02FFFFU
#define UHS_BIG_FLASH 1
#else
#define UHS_BIG_FLASH 0
#endif
#elif defined(IFLASH_SIZE)
#if IFLASH_SIZE > 0x0FFFFU
#define UHS_BIG_FLASH 1
#else
#define UHS_BIG_FLASH 0
#endif
#elif defined(ESP8266)
#define UHS_BIG_FLASH 1
#define SYSTEM_OR_SPECIAL_YIELD(...) yield()
#elif defined(__arm__) && defined(CORE_TEENSY)
#define UHS_BIG_FLASH 1
#elif defined(ARDUINO_spresense_ast)
#define UHS_BIG_FLASH 1
#else
// safe default
#warning Small flash?
#define UHS_BIG_FLASH 0
#endif
#endif
#if UHS_BIG_FLASH
#define UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE 1
#else
#define UHS_DEVICE_WINDOWS_USB_SPEC_VIOLATION_DESCRIPTOR_DEVICE 0
#endif
#endif
#if defined(__arm__) && defined(CORE_TEENSY)
#define UHS_PIN_WRITE(p, v) digitalWriteFast(p, v)
#define UHS_PIN_READ(p) digitalReadFast(p)
#endif
// TODO: Fast inline code for AVR and SAM based microcontrollers
// This can be done pretty easily.
// For now, this will just work out-of-the-box.
#if !defined(UHS_PIN_WRITE)
#define UHS_PIN_WRITE(p, v) digitalWrite(p, v)
#endif
#if !defined(UHS_PIN_READ)
#define UHS_PIN_READ(p) digitalRead(p)
#endif
#if defined( __PIC32MX__ ) && !defined(interrupts) // compiling with Microchip XC32 compiler
#define interrupts() __builtin_enable_interrupts()
#edfine noInterrupts() __builtin_disable_interrupts()
#endif
#if !defined(ARDUINO_SAMD_ZERO)
#if defined(ARDUINO_AVR_ADK)
#define UHS_GET_DPI(x) (x == 54 ? 6 : digitalPinToInterrupt(x))
#else
#define UHS_GET_DPI(x) digitalPinToInterrupt(x)
#endif
#else
#define UHS_GET_DPI(x) (x)
#endif
#ifndef __AVR__
#ifndef __PGMSPACE_H_
// This define should prevent reading the system pgmspace.h if included elsewhere
// This is not normally needed.
#define __PGMSPACE_H_ 1
#endif
#ifndef PROGMEM
#define PROGMEM
#endif
#ifndef PGM_P
#define PGM_P const char *
#endif
#ifndef PSTR
#define PSTR(str) (str)
#endif
#ifndef F
#define F(str) (str)
#endif
#ifndef _SFR_BYTE
#define _SFR_BYTE(n) (n)
#endif
#ifndef memchr_P
#define memchr_P(str, c, len) memchr((str), (c), (len))
#endif
#ifndef memcmp_P
#define memcmp_P(a, b, n) memcmp((a), (b), (n))
#endif
#ifndef memcpy_P
#define memcpy_P(dest, src, num) memcpy((dest), (src), (num))
#endif
#ifndef memmem_P
#define memmem_P(a, alen, b, blen) memmem((a), (alen), (b), (blen))
#endif
#ifndef memrchr_P
#define memrchr_P(str, val, len) memrchr((str), (val), (len))
#endif
#ifndef strcat_P
#define strcat_P(dest, src) strcat((dest), (src))
#endif
#ifndef strchr_P
#define strchr_P(str, c) strchr((str), (c))
#endif
#ifndef strchrnul_P
#define strchrnul_P(str, c) strchrnul((str), (c))
#endif
#ifndef strcmp_P
#define strcmp_P(a, b) strcmp((a), (b))
#endif
#ifndef strcpy_P
#define strcpy_P(dest, src) strcpy((dest), (src))
#endif
#ifndef strcasecmp_P
#define strcasecmp_P(a, b) strcasecmp((a), (b))
#endif
#ifndef strcasestr_P
#define strcasestr_P(a, b) strcasestr((a), (b))
#endif
#ifndef strlcat_P
#define strlcat_P(dest, src, len) strlcat((dest), (src), (len))
#endif
#ifndef strlcpy_P
#define strlcpy_P(dest, src, len) strlcpy((dest), (src), (len))
#endif
#ifndef strlen_P
#define strlen_P(s) strlen((const char *)(s))
#endif
#ifndef strnlen_P
#define strnlen_P(str, len) strnlen((str), (len))
#endif
#ifndef strncmp_P
#define strncmp_P(a, b, n) strncmp((a), (b), (n))
#endif
#ifndef strncasecmp_P
#define strncasecmp_P(a, b, n) strncasecmp((a), (b), (n))
#endif
#ifndef strncat_P
#define strncat_P(a, b, n) strncat((a), (b), (n))
#endif
#ifndef strncpy_P
#define strncpy_P(a, b, n) strncmp((a), (b), (n))
#endif
#ifndef strpbrk_P
#define strpbrk_P(str, chrs) strpbrk((str), (chrs))
#endif
#ifndef strrchr_P
#define strrchr_P(str, c) strrchr((str), (c))
#endif
#ifndef strsep_P
#define strsep_P(strp, delim) strsep((strp), (delim))
#endif
#ifndef strspn_P
#define strspn_P(str, chrs) strspn((str), (chrs))
#endif
#ifndef strstr_P
#define strstr_P(a, b) strstr((a), (b))
#endif
#ifndef sprintf_P
#define sprintf_P(s, ...) sprintf((s), __VA_ARGS__)
#endif
#ifndef vfprintf_P
#define vfprintf_P(s, ...) vfprintf((s), __VA_ARGS__)
#endif
#ifndef printf_P
#define printf_P(...) printf(__VA_ARGS__)
#endif
#ifndef snprintf_P
#define snprintf_P(s, n, ...) ((s), (n), __VA_ARGS__)
#endif
#ifndef vsprintf_P
#define vsprintf_P(s, ...) ((s),__VA_ARGS__)
#endif
#ifndef vsnprintf_P
#define vsnprintf_P(s, n, ...) ((s), (n),__VA_ARGS__)
#endif
#ifndef fprintf_P
#define fprintf_P(s, ...) ((s), __VA_ARGS__)
#endif
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
#ifndef pgm_read_float
#define pgm_read_float(addr) (*(const float *)(addr))
#endif
#ifndef pgm_read_byte_near
#define pgm_read_byte_near(addr) pgm_read_byte(addr)
#endif
#ifndef pgm_read_word_near
#define pgm_read_word_near(addr) pgm_read_word(addr)
#endif
#ifndef pgm_read_dword_near
#define pgm_read_dword_near(addr) pgm_read_dword(addr)
#endif
#ifndef pgm_read_float_near
#define pgm_read_float_near(addr) pgm_read_float(addr)
#endif
#ifndef pgm_read_byte_far
#define pgm_read_byte_far(addr) pgm_read_byte(addr)
#endif
#ifndef pgm_read_word_far
#define pgm_read_word_far(addr) pgm_read_word(addr)
#endif
#ifndef pgm_read_dword_far
#define pgm_read_dword_far(addr) pgm_read_dword(addr)
#endif
#ifndef pgm_read_float_far
#define pgm_read_float_far(addr) pgm_read_float(addr)
#endif
#ifndef pgm_read_pointer
#define pgm_read_pointer
#endif
#endif
////////////////////////////////////////////////////////////////////////////////
// HANDY MACROS
////////////////////////////////////////////////////////////////////////////////
// Atmoically set/clear single bits using bitbands.
// Believe it or not, this boils down to a constant,
// and is less code than using |= &= operators.
// Bonus, it makes code easier to read too.
// Bitbanding is a wonderful thing.
#define BITNR(i) (i&0x1?0:i&0x2?1:i&0x4?2:i&0x8?3:i&0x10?4:i&0x20?5:i&0x40?6:i&0x80?7:i&0x100?8:i&0x200?9:i&0x400?10:i&0x800?11:i&0x1000?12:i&0x2000?13:i&0x4000?14:i&0x8000?15:i&0x10000?16:i&0x20000?17:i&0x40000?18:i&0x80000?19:i&0x100000?20:i&0x200000?21:i&0x400000?22:i&0x800000?23:i&0x1000000?24:i&0x2000000?25:i&0x4000000?26:i&0x8000000?27:i&0x10000000?28:i&0x20000000?29:i&0x40000000?30:i&0x80000000?31:32)
#define UHS_KIO_BITBAND_ADDR(r, i) (((uint32_t)&(r) - 0x40000000) * 32 + (i) * 4 + 0x42000000)
#define UHS_KIO_SETBIT_ATOMIC(r, m) (*(uint32_t *)UHS_KIO_BITBAND_ADDR((r), BITNR((m)))) = 1
#define UHS_KIO_CLRBIT_ATOMIC(r, m) (*(uint32_t *)UHS_KIO_BITBAND_ADDR((r), BITNR((m)))) = 0
#define VALUE_BETWEEN(v,l,h) (((v)>(l)) && ((v)<(h)))
#define VALUE_WITHIN(v,l,h) (((v)>=(l)) && ((v)<=(h)))
#define output_pgm_message(wa,fp,mp,el) wa = &mp, fp((char *)pgm_read_pointer(wa), el)
#define output_if_between(v,l,h,wa,fp,mp,el) if(VALUE_BETWEEN(v,l,h)) output_pgm_message(wa,fp,mp[v-(l+1)],el);
#define UHS_SWAP_VALUES(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b)))
#ifndef __BYTE_GRABBING_DEFINED__
#define __BYTE_GRABBING_DEFINED__ 1
#ifdef BROKEN_OPTIMIZER_LITTLE_ENDIAN
// Note: Use this if your compiler generates horrible assembler!
#define UHS_UINT8_BYTE0(__usi__) (((uint8_t *)&(__usi__))[0])
#define UHS_UINT8_BYTE1(__usi__) (((uint8_t *)&(__usi__))[1])
#define UHS_UINT8_BYTE2(__usi__) (((uint8_t *)&(__usi__))[2])
#define UHS_UINT8_BYTE3(__usi__) (((uint8_t *)&(__usi__))[3])
#define UHS_UINT8_BYTE4(__usi__) (((uint8_t *)&(__usi__))[4])
#define UHS_UINT8_BYTE5(__usi__) (((uint8_t *)&(__usi__))[5])
#define UHS_UINT8_BYTE6(__usi__) (((uint8_t *)&(__usi__))[6])
#define UHS_UINT8_BYTE7(__usi__) (((uint8_t *)&(__usi__))[7])
#else
// Note: The cast alone to uint8_t is actually enough.
// GCC throws out the "& 0xff", and the size is no different.
// Some compilers need it.
#define UHS_UINT8_BYTE0(__usi__) ((uint8_t)((__usi__) & 0xff ))
#define UHS_UINT8_BYTE1(__usi__) ((uint8_t)(((__usi__) >> 8) & 0xff))
#define UHS_UINT8_BYTE2(__usi__) ((uint8_t)(((__usi__) >> 16) & 0xff))
#define UHS_UINT8_BYTE3(__usi__) ((uint8_t)(((__usi__) >> 24) & 0xff))
#define UHS_UINT8_BYTE4(__usi__) ((uint8_t)(((__usi__) >> 32) & 0xff))
#define UHS_UINT8_BYTE5(__usi__) ((uint8_t)(((__usi__) >> 40) & 0xff))
#define UHS_UINT8_BYTE6(__usi__) ((uint8_t)(((__usi__) >> 48) & 0xff))
#define UHS_UINT8_BYTE7(__usi__) ((uint8_t)(((__usi__) >> 56) & 0xff))
#endif
#define UHS_UINT16_SET_BYTE1(__usi__) ((uint16_t)(__usi__) << 8)
#define UHS_UINT32_SET_BYTE1(__usi__) ((uint32_t)(__usi__) << 8)
#define UHS_UINT64_SET_BYTE1(__usi__) ((uint64_t)(__usi__) << 8)
#define UHS_UINT32_SET_BYTE2(__usi__) ((uint32_t)(__usi__) << 16)
#define UHS_UINT64_SET_BYTE2(__usi__) ((uint64_t)(__usi__) << 16)
#define UHS_UINT32_SET_BYTE3(__usi__) ((uint32_t)(__usi__) << 24)
#define UHS_UINT64_SET_BYTE3(__usi__) ((uint64_t)(__usi__) << 24)
#define UHS_UINT64_SET_BYTE4(__usi__) ((uint64_t)(__usi__) << 32)
#define UHS_UINT64_SET_BYTE5(__usi__) ((uint64_t)(__usi__) << 40)
#define UHS_UINT64_SET_BYTE6(__usi__) ((uint64_t)(__usi__) << 48)
#define UHS_UINT64_SET_BYTE7(__usi__) ((uint64_t)(__usi__) << 56)
// These are the smallest and fastest ways I have found so far in pure C/C++.
#define UHS_BYTES_TO_UINT16(__usc1__,__usc0__) ((uint16_t)((uint16_t)(__usc0__) | (uint16_t)UHS_UINT16_SET_BYTE1(__usc1__)))
#define UHS_BYTES_TO_UINT32(__usc3__,__usc2__,__usc1__,__usc0__) ((uint32_t)((uint32_t)(__usc0__) | UHS_UINT32_SET_BYTE1(__usc1__) | UHS_UINT32_SET_BYTE2(__usc2__) | UHS_UINT32_SET_BYTE3(__usc3__)))
#define UHS_BYTES_TO_UINT64(__usc7__,__usc6__,__usc5__,__usc4__,__usc3__,__usc2__,__usc1__,__usc0__) ((uint64_t)((uint64_t)__usc0__ | UHS_UINT64_SET_BYTE1(__usc1__) | UHS_UINT64_SET_BYTE2(__usc2__) | UHS_UINT64_SET_BYTE3(__usc3__) | UHS_UINT64_SET_BYTE4(__usc4__) | UHS_UINT64_SET_BYTE5(__usc5__) | UHS_UINT64_SET_BYTE6(__usc6__) | UHS_UINT64_SET_BYTE7(__usc7__)))
#endif
/*
* Debug macros.
* Useful when porting from UHS2.
* Do not use these for any new code.
* Change to better debugging after port is completed.
* Strings are stored in progmem (flash) instead of RAM.
*/
#define USBTRACE1(s,l) (Notify(PSTR(s), l))
#define USBTRACE(s) (USBTRACE1((s), 0x80)); USB_HOST_SERIAL.flush()
#define USBTRACE3(s,r,l) (Notify(PSTR(s), l), D_PrintHex((r), l), Notify(PSTR("\r\n"), l))
#define USBTRACE3X(s,r,l) (Notify(PSTR(s), l), D_PrintHex((r), l))
#define USBTRACE2(s,r) (USBTRACE3((s),(r),0x80)); USB_HOST_SERIAL.flush()
#define USBTRACE2X(s,r) (USBTRACE3X((s),(r),0x80)); USB_HOST_SERIAL.flush()
#define VOID0 ((void)0)
#if !defined(NOTUSED)
#define NOTUSED(...) __VA_ARGS__ __attribute__((unused))
#endif
#endif /* MACROS_H */

91
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_message.h Normal file
View file

@ -0,0 +1,91 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_UHS_host_h_) || defined(__MESSAGE_H__)
#error "Never include UHS_message.h directly; include UHS_Usb.h instead"
#else
#define __MESSAGE_H__
extern int UsbDEBUGlvl;
void E_Notify(char const * msg, int lvl);
void E_Notify(uint8_t b, int lvl);
void E_NotifyStr(char const * msg, int lvl);
void E_Notifyc(char c, int lvl);
#ifdef DEBUG_USB_HOST
#define Notify E_Notify
#define NotifyStr E_NotifyStr
#define Notifyc E_Notifyc
void NotifyFailGetDevDescr(uint8_t reason);
void NotifyFailSetDevTblEntry(uint8_t reason);
void NotifyFailGetConfDescr(uint8_t reason);
void NotifyFailSetConfDescr(uint8_t reason);
void NotifyFailGetDevDescr(void);
void NotifyFailSetDevTblEntry(void);
void NotifyFailGetConfDescr(void);
void NotifyFailSetConfDescr(void);
void NotifyFailUnknownDevice(uint16_t VID, uint16_t PID);
void NotifyFail(uint8_t rcode);
#else
#define Notify(...) VOID0
#define NotifyStr(...) VOID0
#define Notifyc(...) VOID0
#define NotifyFailGetDevDescr(...) VOID0
#define NotifyFailSetDevTblEntry(...) VOID0
#define NotifyFailGetConfDescr(...) VOID0
#define NotifyFailGetDevDescr(...) VOID0
#define NotifyFailSetDevTblEntry(...) VOID0
#define NotifyFailGetConfDescr(...) VOID0
#define NotifyFailSetConfDescr(...) VOID0
#define NotifyFailUnknownDevice(...) VOID0
#define NotifyFail(...) VOID0
#endif
#ifdef DEBUG_USB_HOST
template <class ERROR_TYPE> void ErrorMessage(uint8_t level, char const * msg, ERROR_TYPE rcode = 0) {
Notify(msg, level);
Notify(PSTR(": "), level);
D_PrintHex<ERROR_TYPE > (rcode, level);
Notify(PSTR("\r\n"), level);
#else
template <class ERROR_TYPE> void ErrorMessage(NOTUSED(uint8_t level), NOTUSED(char const * msg), ERROR_TYPE rcode = 0) {
(void)rcode;
#endif
}
#ifdef DEBUG_USB_HOST
template <class ERROR_TYPE> void ErrorMessage(char const * msg, ERROR_TYPE rcode = 0) {
Notify(msg, 0x80);
Notify(PSTR(": "), 0x80);
D_PrintHex<ERROR_TYPE > (rcode, 0x80);
Notify(PSTR("\r\n"), 0x80);
#else
template <class ERROR_TYPE> void ErrorMessage(NOTUSED(char const * msg), ERROR_TYPE rcode = 0) {
(void)rcode;
#endif
}
#endif // __MESSAGE_H__

201
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_printf_HELPER.h Normal file
View file

@ -0,0 +1,201 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#ifndef UHS_PRINTF_HELPER_H
#define UHS_PRINTF_HELPER_H
#if defined(LOAD_UHS_PRINTF_HELPER)
#include <Arduino.h>
#ifdef true
#undef true
#endif
#ifdef false
#undef false
#endif
#if !defined(STDIO_IS_OK_TO_USE_AS_IS)
#if defined(ARDUINO_SAMD_ZERO) || defined(ARDUINO_SAM_DUE) || defined(ARDUINO_spresense_ast)
// STDIO patching not required.
#define STDIO_IS_OK_TO_USE_AS_IS
#endif
#endif
#if !defined(STDIO_IS_OK_TO_USE_AS_IS)
// We need to patch STDIO so it can be used.
#ifndef SERIAL_PORT_MONITOR
// Some don't define this.
#define SERIAL_PORT_MONITOR Serial
#endif
#ifndef SERIAL_PORT_HARDWARE
// Some don't define this.
#define SERIAL_PORT_HARDWARE SERIAL_PORT_MONITOR
#endif
#ifndef USB_HOST_SERIAL
#if defined(SERIAL_PORT_USBVIRTUAL) && defined(LOAD_UHS_KINETIS_FS_HOST)
#define USB_HOST_SERIAL SERIAL_PORT_HARDWARE
#else
#define USB_HOST_SERIAL SERIAL_PORT_MONITOR
#endif
#endif
#if !defined(NOTUSED)
#define NOTUSED(...) __VA_ARGS__ __attribute__((unused))
#endif
#ifndef __AVR__
#ifndef printf_P
#define printf_P(...) printf(__VA_ARGS__)
#endif
#endif
#if defined(ARDUINO_ARCH_PIC32)
/*
* For printf() output with pic32 Arduino
*/
extern "C" {
void _mon_putc(char s) {
USB_HOST_SERIAL.write(s);
}
int _mon_getc() {
while(!USB_HOST_SERIAL.available());
return USB_HOST_SERIAL.read();
}
}
#elif defined(__AVR__)
extern "C" {
static FILE tty_stdio;
static FILE tty_stderr;
static int NOTUSED(tty_stderr_putc(char c, NOTUSED(FILE *t)));
static int NOTUSED(tty_stderr_flush(NOTUSED(FILE *t)));
static int NOTUSED(tty_std_putc(char c, NOTUSED(FILE *t)));
static int NOTUSED(tty_std_getc(NOTUSED(FILE *t)));
static int NOTUSED(tty_std_flush(NOTUSED(FILE *t)));
static int tty_stderr_putc(char c, NOTUSED(FILE *t)) {
USB_HOST_SERIAL.write(c);
return 0;
}
static int tty_stderr_flush(NOTUSED(FILE *t)) {
USB_HOST_SERIAL.flush();
return 0;
}
static int tty_std_putc(char c, NOTUSED(FILE *t)) {
USB_HOST_SERIAL.write(c);
return 0;
}
static int tty_std_getc(NOTUSED(FILE *t)) {
while(!USB_HOST_SERIAL.available());
return USB_HOST_SERIAL.read();
}
static int tty_std_flush(NOTUSED(FILE *t)) {
USB_HOST_SERIAL.flush();
return 0;
}
}
#elif defined(CORE_TEENSY)
extern "C" {
int _write(int fd, const char *ptr, int len) {
int j;
for(j = 0; j < len; j++) {
if(fd == 1)
USB_HOST_SERIAL.write(*ptr++);
else if(fd == 2)
USB_HOST_SERIAL.write(*ptr++);
}
return len;
}
int _read(int fd, char *ptr, int len) {
if(len > 0 && fd == 0) {
while(!USB_HOST_SERIAL.available());
*ptr = USB_HOST_SERIAL.read();
return 1;
}
return 0;
}
#include <sys/stat.h>
int _fstat(int fd, struct stat *st) {
memset(st, 0, sizeof (*st));
st->st_mode = S_IFCHR;
st->st_blksize = 1024;
return 0;
}
int _isatty(int fd) {
return (fd < 3) ? 1 : 0;
}
}
#else
#error no STDIO
#endif // defined(ARDUINO_ARCH_PIC32)
#if defined(__AVR__)
// The only wierdo in the bunch...
void UHS_AVR_printf_HELPER_init(void) {
// Set up stdio/stderr
tty_stdio.put = tty_std_putc;
tty_stdio.get = tty_std_getc;
tty_stdio.flags = _FDEV_SETUP_RW;
tty_stdio.udata = 0;
tty_stderr.put = tty_stderr_putc;
tty_stderr.get = NULL;
tty_stderr.flags = _FDEV_SETUP_WRITE;
tty_stderr.udata = 0;
stdout = &tty_stdio;
stdin = &tty_stdio;
stderr = &tty_stderr;
}
#define UHS_printf_HELPER_init() UHS_AVR_printf_HELPER_init()
#endif
#endif /* STDIO_IS_OK_TO_USE_AS_IS */
#endif /* load.... */
#if !defined(UHS_printf_HELPER_init)
#define UHS_printf_HELPER_init() (void(0))
#endif
#endif /* UHS_PRINTF_HELPER_H */

96
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_printhex.h Normal file
View file

@ -0,0 +1,96 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_UHS_host_h_) || defined(__PRINTHEX_H__)
#error "Never include UHS_printhex.h directly; include UHS_Usb.h instead"
#else
#define __PRINTHEX_H__
void E_Notifyc(char c, int lvl);
template <class T>
void PrintHex(T val, int lvl) {
int num_nibbles = sizeof (T) * 2;
do {
char v = 48 + (((val >> (num_nibbles - 1) * 4)) & 0x0f);
if(v > 57) v += 7;
E_Notifyc(v, lvl);
} while(--num_nibbles);
}
template <class T>
void PrintBin(T val, int lvl) {
for(T mask = (((T)1) << ((sizeof (T) << 3) - 1)); mask; mask >>= 1)
if(val & mask)
E_Notifyc('1', lvl);
else
E_Notifyc('0', lvl);
}
template <class T>
void SerialPrintHex(T val) {
int num_nibbles = sizeof (T) * 2;
do {
char v = 48 + (((val >> (num_nibbles - 1) * 4)) & 0x0f);
if(v > 57) v += 7;
USB_HOST_SERIAL.print(v);
} while(--num_nibbles);
}
template <class T>
void PrintHex2(Print *prn, T val) {
T mask = (((T)1) << (((sizeof (T) << 1) - 1) << 2));
while(mask > 1) {
if(val < mask)
prn->print("0");
mask >>= 4;
}
prn->print((T)val, HEX);
}
#ifdef DEBUG_USB_HOST
template <class T> void D_PrintHex(T val, int lvl) {
PrintHex<T > (val, lvl);
#else
template <class T> void D_PrintHex(NOTUSED(T val), NOTUSED(int lvl)) {
#endif
}
#ifdef DEBUG_USB_HOST
template <class T> void D_PrintBin(T val, int lvl) {
PrintBin<T > (val, lvl);
#else
template <class T> void D_PrintBin(NOTUSED(T val), NOTUSED(int lvl)) {
#endif
}
#endif // __PRINTHEX_H__

141
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_settings.h Normal file
View file

@ -0,0 +1,141 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#ifndef UHS_SETTINGS_H
#define UHS_SETTINGS_H
// TO-DO: Move specific settings to modules which use them.
////////////////////////////////////////////////////////////////////////////////
// Define any of these options at the top of your sketch to override
// the defaults contained herewith. Do NOT do modifications here.
// Individual Components have their own settings.
//
// Macro | Settings and notes | Default
// -----------------------------+-----------------------+-----------------------
// | Any class that does |
// USB_HOST_SERIAL | text streaming | SERIAL_PORT_MONITOR
// | e.g. Serial2 |
// -----------------------------+-----------------------+-----------------------
// ENABLE_UHS_DEBUGGING | 0 = off, 1 = on | 0
// -----------------------------+-----------------------+-----------------------
// | 0 = off, 1 = on |
// | Caution! Can make |
// DEBUG_PRINTF_EXTRA_HUGE | program too large! | 0
// | Other modules depend |
// | on this setting. |
// -----------------------------+-----------------------+-----------------------
// USE_UHS_BLACK_WIDDOW | 0 = no, 1 = yes | 0
// -----------------------------+-----------------------+-----------------------
// ENABLE_WII_IR_CAMERA | 0 = no, 1 = yes | 0
// -----------------------------^-----------------------^-----------------------
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// DEBUGGING
////////////////////////////////////////////////////////////////////////////////
#ifndef USB_HOST_SERIAL
#if defined(SERIAL_PORT_USBVIRTUAL) && defined(LOAD_UHS_KINETIS_FS_HOST)
#define USB_HOST_SERIAL SERIAL_PORT_HARDWARE
#else
#define USB_HOST_SERIAL SERIAL_PORT_MONITOR
#endif
#endif
#ifndef ENABLE_UHS_DEBUGGING
#define ENABLE_UHS_DEBUGGING 0
#endif
#ifndef DEBUG_PRINTF_EXTRA_HUGE
#define DEBUG_PRINTF_EXTRA_HUGE 0
#endif
////////////////////////////////////////////////////////////////////////////////
// Manual board activation
////////////////////////////////////////////////////////////////////////////////
/* Set this to 1 if you are using a Black Widdow */
#ifndef USE_UHS_BLACK_WIDDOW
#define USE_UHS_BLACK_WIDDOW 0
#endif
////////////////////////////////////////////////////////////////////////////////
// Wii IR camera
////////////////////////////////////////////////////////////////////////////////
/* Set this to 1 to activate code for the Wii IR camera */
#ifndef ENABLE_WII_IR_CAMERA
#define ENABLE_WII_IR_CAMERA 0
#endif
////////////////////////////////////////////////////////////////////////////////
// Set to 1 to use the faster spi4teensy3 driver. (not used yet))
////////////////////////////////////////////////////////////////////////////////
#ifndef USE_SPI4TEENSY3
#define USE_SPI4TEENSY3 0
#endif
////////////////////////////////////////////////////////////////////////////////
// AUTOMATIC Settings
////////////////////////////////////////////////////////////////////////////////
// No user serviceable parts below this line.
// DO NOT change anything below here unless you are a developer!
#if defined(__GNUC__) && defined(__AVR__)
#ifndef GCC_VERSION
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#endif
#if GCC_VERSION < 40602 // Test for GCC < 4.6.2
#ifdef PROGMEM
#undef PROGMEM
#define PROGMEM __attribute__((section(".progmem.data"))) // Workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34734#c4
#ifdef PSTR
#undef PSTR
#define PSTR(s) (__extension__({static const char __c[] PROGMEM = (s); &__c[0];})) // Copied from pgmspace.h in avr-libc source
#endif
#endif
#endif
#endif
#if !defined(DEBUG_USB_HOST) && ENABLE_UHS_DEBUGGING
#define DEBUG_USB_HOST
#endif
#if !defined(WIICAMERA) && ENABLE_WII_IR_CAMERA
#define WIICAMERA
#endif
#define UHS_SLEEP_MS(v) pUsb->sof_delay(v)
#ifndef UHS_NI
#define UHS_NI __attribute__((noinline))
#endif
#endif /* SETTINGS_H */

222
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_usb_ch9.h Normal file
View file

@ -0,0 +1,222 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_UHS_host_h_) || defined(_UHS_ch9_h_)
#error "Never include UHS_usb_ch9.h directly; include UHS_Usb.h instead"
#else
/* USB chapter 9 structures */
#define _UHS_ch9_h_
/* Misc.USB constants */
#define DEV_DESCR_LEN 18 //device descriptor length
#define CONF_DESCR_LEN 9 //configuration descriptor length
#define INTR_DESCR_LEN 9 //interface descriptor length
#define EP_DESCR_LEN 7 //endpoint descriptor length
/* Standard Device Requests */
#define USB_REQUEST_GET_STATUS 0 // Standard Device Request - GET STATUS
#define USB_REQUEST_CLEAR_FEATURE 1 // Standard Device Request - CLEAR FEATURE
#define USB_REQUEST_SET_FEATURE 3 // Standard Device Request - SET FEATURE
#define USB_REQUEST_SET_ADDRESS 5 // Standard Device Request - SET ADDRESS
#define USB_REQUEST_GET_DESCRIPTOR 6 // Standard Device Request - GET DESCRIPTOR
#define USB_REQUEST_SET_DESCRIPTOR 7 // Standard Device Request - SET DESCRIPTOR
#define USB_REQUEST_GET_CONFIGURATION 8 // Standard Device Request - GET CONFIGURATION
#define USB_REQUEST_SET_CONFIGURATION 9 // Standard Device Request - SET CONFIGURATION
#define USB_REQUEST_GET_INTERFACE 10 // Standard Device Request - GET INTERFACE
#define USB_REQUEST_SET_INTERFACE 11 // Standard Device Request - SET INTERFACE
#define USB_REQUEST_SYNCH_FRAME 12 // Standard Device Request - SYNCH FRAME
/* Wireless USB Device Requests */
#define USB_REQ_SET_ENCRYPTION 0x0D
#define USB_REQ_GET_ENCRYPTION 0x0E
#define USB_REQ_RPIPE_ABORT 0x0E
#define USB_REQ_SET_HANDSHAKE 0x0F
#define USB_REQ_RPIPE_RESET 0x0F
#define USB_REQ_GET_HANDSHAKE 0x10
#define USB_REQ_SET_CONNECTION 0x11
#define USB_REQ_SET_SECURITY_DATA 0x12
#define USB_REQ_GET_SECURITY_DATA 0x13
#define USB_REQ_SET_WUSB_DATA 0x14
#define USB_REQ_LOOPBACK_DATA_WRITE 0x15
#define USB_REQ_LOOPBACK_DATA_READ 0x16
#define USB_REQ_SET_INTERFACE_DS 0x17
/* USB feature flags */
#define USB_DEVICE_SELF_POWERED 0 /* (read only) */
#define USB_DEVICE_REMOTE_WAKEUP 1 /* dev may initiate wakeup */
#define USB_DEVICE_TEST_MODE 2 /* (wired high speed only) */
#define USB_DEVICE_BATTERY 2 /* (wireless) */
#define USB_DEVICE_B_HNP_ENABLE 3 /* (otg) dev may initiate HNP */
#define USB_DEVICE_WUSB_DEVICE 3 /* (wireless)*/
#define USB_DEVICE_A_HNP_SUPPORT 4 /* (otg) RH port supports HNP */
#define USB_DEVICE_A_ALT_HNP_SUPPORT 5 /* (otg) other RH port does */
#define USB_DEVICE_DEBUG_MODE 6 /* (special devices only) */
#define USB_FEATURE_ENDPOINT_HALT 0 // CLEAR/SET FEATURE - Endpoint Halt
#define USB_FEATURE_DEVICE_REMOTE_WAKEUP 1 // CLEAR/SET FEATURE - Device remote wake-up
#define USB_FEATURE_TEST_MODE 2 // CLEAR/SET FEATURE - Test mode
/* OTG SET FEATURE Constants */
#define OTG_FEATURE_B_HNP_ENABLE 3 // SET FEATURE OTG - Enable B device to perform HNP
#define OTG_FEATURE_A_HNP_SUPPORT 4 // SET FEATURE OTG - A device supports HNP
#define OTG_FEATURE_A_ALT_HNP_SUPPORT 5 // SET FEATURE OTG - Another port on the A device supports HNP
/* Setup Data Constants */
#define USB_SETUP_HOST_TO_DEVICE 0x00 // Device Request bmRequestType transfer direction - host to device transfer
#define USB_SETUP_DEVICE_TO_HOST 0x80 // Device Request bmRequestType transfer direction - device to host transfer
#define USB_SETUP_TYPE_STANDARD 0x00 // Device Request bmRequestType type - standard
#define USB_SETUP_TYPE_CLASS 0x20 // Device Request bmRequestType type - class
#define USB_SETUP_TYPE_VENDOR 0x40 // Device Request bmRequestType type - vendor
#define USB_SETUP_RECIPIENT_DEVICE 0x00 // Device Request bmRequestType recipient - device
#define USB_SETUP_RECIPIENT_INTERFACE 0x01 // Device Request bmRequestType recipient - interface
#define USB_SETUP_RECIPIENT_ENDPOINT 0x02 // Device Request bmRequestType recipient - endpoint
#define USB_SETUP_RECIPIENT_OTHER 0x03 // Device Request bmRequestType recipient - other
#define USB_SETUP_RECIPIENT_PORT 0x04 // Wireless USB 1.0
#define USB_SETUP_RECIPIENT_RPIPE 0x05 // Wireless USB 1.0
/* USB descriptors */
#define USB_DESCRIPTOR_DEVICE 0x01 // bDescriptorType for a Device Descriptor.
#define USB_DESCRIPTOR_CONFIGURATION 0x02 // bDescriptorType for a Configuration Descriptor.
#define USB_DESCRIPTOR_STRING 0x03 // bDescriptorType for a String Descriptor.
#define USB_DESCRIPTOR_INTERFACE 0x04 // bDescriptorType for an Interface Descriptor.
#define USB_DESCRIPTOR_ENDPOINT 0x05 // bDescriptorType for an Endpoint Descriptor.
#define USB_DESCRIPTOR_DEVICE_QUALIFIER 0x06 // bDescriptorType for a Device Qualifier.
#define USB_DESCRIPTOR_OTHER_SPEED 0x07 // bDescriptorType for a Other Speed Configuration.
#define USB_DESCRIPTOR_INTERFACE_POWER 0x08 // bDescriptorType for Interface Power.
#define USB_DESCRIPTOR_OTG 0x09 // bDescriptorType for an OTG Descriptor.
#define USB_DESCRIPTOR_DEBUG 0x0a
#define USB_DESCRIPTOR_INTERFACE_ASSOCIATION 0x0b
#define USB_DESCRIPTOR_SECURITY 0x0c
#define USB_DESCRIPTOR_KEY 0x0d
#define USB_DESCRIPTOR_ENCRYPTION_TYPE 0x0e
#define USB_DESCRIPTOR_BOS 0x0f
#define USB_DESCRIPTOR_DEVICE_CAPABILITY 0x10
#define USB_DESCRIPTOR_WIRELESS_ENDPOINT_COMP 0x11
#define USB_DESCRIPTOR_WIRE_ADAPTER 0x21
#define USB_DESCRIPTOR_RPIPE 0x22
#define USB_DESCRIPTOR_CS_RADIO_CONTROL 0x23
#define USB_DESCRIPTOR_SS_ENDPOINT_COMP 0x30
#define USB_HID_DESCRIPTOR 0x21
// Conventional codes for class-specific descriptors. "Common Class" Spec (3.11)
#define USB_DESCRIPTOR_CS_DEVICE 0x21
#define USB_DESCRIPTOR_CS_CONFIG 0x22
#define USB_DESCRIPTOR_CS_STRING 0x23
#define USB_DESCRIPTOR_CS_INTERFACE 0x24
#define USB_DESCRIPTOR_CS_ENDPOINT 0x25
/* USB Endpoint Transfer Types */
#define USB_TRANSFER_TYPE_CONTROL 0x00 // Endpoint is a control endpoint.
#define USB_TRANSFER_TYPE_ISOCHRONOUS 0x01 // Endpoint is an isochronous endpoint.
#define USB_TRANSFER_TYPE_BULK 0x02 // Endpoint is a bulk endpoint.
#define USB_TRANSFER_TYPE_INTERRUPT 0x03 // Endpoint is an interrupt endpoint.
#define bmUSB_TRANSFER_TYPE 0x03 // bit mask to separate transfer type from ISO attributes
#define USB_TRANSFER_DIRECTION_IN 0x80 // Indicate direction is IN
/* Standard Feature Selectors for CLEAR_FEATURE Requests */
#define USB_FEATURE_ENDPOINT_STALL 0 // Endpoint recipient
#define USB_FEATURE_DEVICE_REMOTE_WAKEUP 1 // Device recipient
#define USB_FEATURE_TEST_MODE 2 // Device recipient
/* descriptor data structures */
/* Device descriptor structure */
typedef struct {
uint8_t bLength; // Length of this descriptor.
uint8_t bDescriptorType; // DEVICE descriptor type (USB_DESCRIPTOR_DEVICE).
uint16_t bcdUSB; // USB Spec Release Number (BCD).
uint8_t bDeviceClass; // Class code (assigned by the USB-IF). 0xFF-Vendor specific.
uint8_t bDeviceSubClass; // Subclass code (assigned by the USB-IF).
uint8_t bDeviceProtocol; // Protocol code (assigned by the USB-IF). 0xFF-Vendor specific.
uint8_t bMaxPacketSize0; // Maximum packet size for endpoint 0.
uint16_t idVendor; // Vendor ID (assigned by the USB-IF).
uint16_t idProduct; // Product ID (assigned by the manufacturer).
uint16_t bcdDevice; // Device release number (BCD).
uint8_t iManufacturer; // Index of String Descriptor describing the manufacturer.
uint8_t iProduct; // Index of String Descriptor describing the product.
uint8_t iSerialNumber; // Index of String Descriptor with the device's serial number.
uint8_t bNumConfigurations; // Number of possible configurations.
} __attribute__((packed)) USB_DEVICE_DESCRIPTOR;
/* Configuration descriptor structure */
typedef struct {
uint8_t bLength; // Length of this descriptor.
uint8_t bDescriptorType; // CONFIGURATION descriptor type (USB_DESCRIPTOR_CONFIGURATION).
uint16_t wTotalLength; // Total length of all descriptors for this configuration.
uint8_t bNumInterfaces; // Number of interfaces in this configuration.
uint8_t bConfigurationValue; // Value of this configuration (1 based).
uint8_t iConfiguration; // Index of String Descriptor describing the configuration.
uint8_t bmAttributes; // Configuration characteristics.
uint8_t bMaxPower; // Maximum power consumed by this configuration.
} __attribute__((packed)) USB_CONFIGURATION_DESCRIPTOR;
/* Interface descriptor structure */
typedef struct {
uint8_t bLength; // Length of this descriptor.
uint8_t bDescriptorType; // INTERFACE descriptor type (USB_DESCRIPTOR_INTERFACE).
uint8_t bInterfaceNumber; // Number of this interface (0 based).
uint8_t bAlternateSetting; // Value of this alternate interface setting.
uint8_t bNumEndpoints; // Number of endpoints in this interface.
uint8_t bInterfaceClass; // Class code (assigned by the USB-IF). 0xFF-Vendor specific.
uint8_t bInterfaceSubClass; // Subclass code (assigned by the USB-IF).
uint8_t bInterfaceProtocol; // Protocol code (assigned by the USB-IF). 0xFF-Vendor specific.
uint8_t iInterface; // Index of String Descriptor describing the interface.
} __attribute__((packed)) USB_INTERFACE_DESCRIPTOR;
/* Endpoint descriptor structure */
typedef struct {
uint8_t bLength; // Length of this descriptor.
uint8_t bDescriptorType; // ENDPOINT descriptor type (USB_DESCRIPTOR_ENDPOINT).
uint8_t bEndpointAddress; // Endpoint address. Bit 7 indicates direction (0=OUT, 1=IN).
uint8_t bmAttributes; // Endpoint transfer type.
uint16_t wMaxPacketSize; // Maximum packet size.
uint8_t bInterval; // Polling interval in frames.
} __attribute__((packed)) USB_ENDPOINT_DESCRIPTOR;
/* HID descriptor */
/*
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t bcdHID; // HID class specification release
uint8_t bCountryCode;
uint8_t bNumDescriptors; // Number of additional class specific descriptors
uint8_t bDescrType; // Type of class descriptor
uint16_t wDescriptorLength; // Total size of the Report descriptor
} __attribute__((packed)) USB_HID_DESCRIPTOR;
*/
typedef struct {
uint8_t bDescrType; // Type of class descriptor
uint16_t wDescriptorLength; // Total size of the Report descriptor
} __attribute__((packed)) HID_CLASS_DESCRIPTOR_LEN_AND_TYPE;
#endif // _ch9_h_

452
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_usbhost.h Normal file
View file

@ -0,0 +1,452 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(_UHS_host_h_)
#error "Never include UHS_usbhost.h directly; include UHS_host.h instead"
#else
#if !defined(_USBHOST_H_)
#define _USBHOST_H_
// Very early prototypes
#if defined(UHS_LOAD_BT)
void UHS_BT_SetUSBInterface(UHS_USB_HOST_BASE *host, ENUMERATION_INFO *ei);
void UHS_BT_ScanUninitialized(UHS_USB_HOST_BASE *host);
void UHS_BT_Poll(UHS_USB_HOST_BASE *host);
#endif
#if defined(UHS_LOAD_HID)
void UHS_HID_SetUSBInterface(UHS_USB_HOST_BASE *host, ENUMERATION_INFO *ei);
void UHS_HID_ScanUninitialized(UHS_USB_HOST_BASE *host);
void UHS_HID_Poll(UHS_USB_HOST_BASE *host);
#endif
//#if defined(LOAD_UHS_CDC_ACM) || defined(LOAD_UHS_CDC_ACM_FTDI) || defined(LOAD_UHS_CDC_ACM_PROLIFIC) || defined(LOAD_UHS_CDC_ACM_XR21B1411)
//void UHS_CDC_ACM_SetUSBInterface(UHS_USB_HOST_BASE *host, ENUMERATION_INFO *ei);
//void UHS_CDC_ACM_ScanUninitialized(UHS_USB_HOST_BASE *host);
//void UHS_CDC_ACM_Poll(UHS_USB_HOST_BASE *host);
//#endif
class UHS_USBInterface; // forward class declaration
// enumerator to turn the VBUS on/off
typedef enum {
vbus_on = 0,
vbus_off = 1
} VBUS_t;
// All host SEI use this base class
class UHS_USB_HOST_BASE {
public:
AddressPool addrPool;
UHS_USBInterface* devConfig[UHS_HOST_MAX_INTERFACE_DRIVERS];
volatile uint8_t usb_error;
volatile uint8_t usb_task_state;
volatile uint8_t usb_task_polling_disabled;
volatile uint8_t usb_host_speed;
volatile uint8_t hub_present;
UHS_USB_HOST_BASE(void) {
for(uint16_t i = 0; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) {
devConfig[i] = NULL;
}
usb_task_polling_disabled = 0;
usb_task_state = UHS_USB_HOST_STATE_INITIALIZE; //set up state machine
usb_host_speed = 0;
usb_error = 0;
};
/////////////////////////////////////////////
//
// Virtual methods that interface to the SIE
// Overriding each is mandatory.
//
/////////////////////////////////////////////
/**
* Delay for x milliseconds
* Override if your controller provides an SOF IRQ, which may involve
* some sort of reentrant ISR or workaround with interrupts enabled.
*
* @param x how many milliseconds to delay
* @return true if delay completed without a state change, false if delay aborted
*/
virtual bool UHS_NI sof_delay(uint16_t x) {
if(!(usb_task_state & UHS_USB_HOST_STATE_MASK)) return false;
uint8_t current_state = usb_task_state;
while(current_state == usb_task_state && x--) {
delay(1);
}
return (current_state == usb_task_state);
};
virtual UHS_EpInfo * UHS_NI ctrlReqOpen(NOTUSED(uint8_t addr), NOTUSED(uint64_t Request), NOTUSED(uint8_t* dataptr)) {
return NULL;
};
virtual void UHS_NI vbusPower(NOTUSED(VBUS_t state)) {
};
virtual void UHS_NI Task(void) {
};
virtual uint8_t UHS_NI SetAddress(NOTUSED(uint8_t addr), NOTUSED(uint8_t ep), NOTUSED(UHS_EpInfo **ppep), NOTUSED(uint16_t &nak_limit)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t UHS_NI OutTransfer(NOTUSED(UHS_EpInfo *pep), NOTUSED(uint16_t nak_limit), NOTUSED(uint16_t nbytes), NOTUSED(uint8_t *data)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t UHS_NI InTransfer(NOTUSED(UHS_EpInfo *pep), NOTUSED(uint16_t nak_limit), NOTUSED(uint16_t *nbytesptr), NOTUSED(uint8_t *data)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t UHS_NI ctrlReqClose(NOTUSED(UHS_EpInfo *pep), NOTUSED(uint8_t bmReqType), NOTUSED(uint16_t left), NOTUSED(uint16_t nbytes), NOTUSED(uint8_t *dataptr)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t UHS_NI ctrlReqRead(NOTUSED(UHS_EpInfo *pep), NOTUSED(uint16_t *left), NOTUSED(uint16_t *read), NOTUSED(uint16_t nbytes), NOTUSED(uint8_t *dataptr)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t UHS_NI dispatchPkt(NOTUSED(uint8_t token), NOTUSED(uint8_t ep), NOTUSED(uint16_t nak_limit)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t UHS_NI init(void) {
return 0;
};
virtual void UHS_NI doHostReset(void) {
};
virtual int16_t UHS_NI Init(NOTUSED(int16_t mseconds)) {
return -1;
};
virtual int16_t UHS_NI Init(void) {
return Init(INT16_MIN);
};
virtual uint8_t hwlPowerUp(void) {
/* This is for machine specific support to enable/power up the USB HW to operate*/
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual uint8_t hwPowerDown(void) {
/* This is for machine specific support to disable/powerdown the USB Hw */
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
virtual bool IsHub(uint8_t klass) {
return (klass == UHS_USB_CLASS_HUB);
};
virtual void UHS_NI suspend_host(void) {
// Used on MCU that lack control of IRQ priority (AVR).
// Suspends ISRs, for critical code. IRQ will be serviced after it is resumed.
// NOTE: you must track the state yourself!
};
virtual void UHS_NI resume_host(void) {
// Used on MCU that lack control of IRQ priority (AVR).
// Resumes ISRs.
// NOTE: you must track the state yourself!
};
/////////////////////////////////////////////
//
// Built-ins, No need to override
//
/////////////////////////////////////////////
// these two probably will go away, and won't be used, TBD
inline void Poll_Others(void) {
#if defined(UHS_LOAD_BT)
UHS_BT_Poll(this);
#endif
#if defined(UHS_LOAD_HID)
UHS_HID_Poll(this);
#endif
}
inline void DisablePoll(void) {
noInterrupts();
usb_task_polling_disabled++;
DDSB();
interrupts();
}
inline void EnablePoll(void) {
noInterrupts();
usb_task_polling_disabled--;
DDSB();
interrupts();
}
uint8_t UHS_NI seekInterface(ENUMERATION_INFO *ei, uint16_t inf, USB_CONFIGURATION_DESCRIPTOR *ucd);
uint8_t UHS_NI setEpInfoEntry(uint8_t addr, uint8_t iface, uint8_t epcount, volatile UHS_EpInfo* eprecord_ptr);
uint8_t UHS_NI EPClearHalt(uint8_t addr, uint8_t ep);
uint8_t UHS_NI ctrlReq(uint8_t addr, uint64_t Request, uint16_t nbytes, uint8_t* dataptr);
uint8_t UHS_NI getDevDescr(uint8_t addr, uint16_t nbytes, uint8_t* dataptr);
uint8_t UHS_NI getConfDescr(uint8_t addr, uint16_t nbytes, uint8_t conf, uint8_t* dataptr);
uint8_t UHS_NI setAddr(uint8_t oldaddr, uint8_t newaddr);
uint8_t UHS_NI setConf(uint8_t addr, uint8_t conf_value);
uint8_t UHS_NI getStrDescr(uint8_t addr, uint16_t nbytes, uint8_t index, uint16_t langid, uint8_t* dataptr);
void UHS_NI ReleaseDevice(uint8_t addr);
uint8_t UHS_NI Configuring(uint8_t parent, uint8_t port, uint8_t speed);
void UHS_NI DeviceDefaults(uint8_t maxep, UHS_USBInterface *device);
UHS_EpInfo* UHS_NI getEpInfoEntry(uint8_t addr, uint8_t ep);
inline uint8_t getUsbTaskState(void) {
return ( usb_task_state);
};
inline AddressPool* GetAddressPool(void) {
return &addrPool;
};
int UHS_NI RegisterDeviceClass(UHS_USBInterface *pdev) {
for(uint8_t i = 0; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++) {
if(!devConfig[i]) {
devConfig[i] = pdev;
return i;
}
}
//return UHS_HOST_ERROR_CANT_REGISTER_DEVICE_CLASS;
return -1;
};
#if 0
inline void ForEachUsbDevice(UsbDeviceHandleFunc pfunc) {
addrPool.ForEachUsbDevice(pfunc);
};
#endif
uint8_t TestInterface(ENUMERATION_INFO *ei);
uint8_t enumerateInterface(ENUMERATION_INFO *ei);
uint8_t getNextInterface(ENUMERATION_INFO *ei, UHS_EpInfo *pep, uint8_t data[], uint16_t *left, uint16_t *read, uint8_t *offset);
uint8_t initDescrStream(ENUMERATION_INFO *ei, USB_CONFIGURATION_DESCRIPTOR *ucd, UHS_EpInfo *pep, uint8_t *data, uint16_t *left, uint16_t *read, uint8_t *offset);
uint8_t outTransfer(uint8_t addr, uint8_t ep, uint16_t nbytes, uint8_t* data);
uint8_t inTransfer(uint8_t addr, uint8_t ep, uint16_t *nbytesptr, uint8_t* data);
uint8_t doSoftReset(uint8_t parent, uint8_t port, uint8_t address);
uint8_t getone(UHS_EpInfo *pep, uint16_t *left, uint16_t *read, uint8_t *dataptr, uint8_t *offset);
uint8_t eat(UHS_EpInfo *pep, uint16_t *left, uint16_t *read, uint8_t *dataptr, uint8_t *offset, uint16_t *yum);
};
// All device interface drivers use this subclass
class UHS_USBInterface {
public:
UHS_USB_HOST_BASE *pUsb; // Parent USB host
volatile uint8_t bNumEP; // total number of EP in this interface
volatile UHS_EpInfo epInfo[16]; // This is a stub, override in the driver.
volatile uint8_t bAddress; // address of the device
volatile uint8_t bConfNum; // configuration number
volatile uint8_t bIface; // interface value
volatile bool bPollEnable; // poll enable flag, operating status
volatile uint32_t qNextPollTime; // next poll time
/**
* Resets interface driver to unused state. You should override this in
* your driver if it requires extra class variable cleanup.
*/
virtual void DriverDefaults(void) {
printf("Default driver defaults.\r\n");
pUsb->DeviceDefaults(bNumEP, this);
};
/**
* Checks if this interface is supported.
* Executed called when new devices are connected.
*
* @param ei
* @return true if the interface is supported
*/
virtual bool OKtoEnumerate(NOTUSED(ENUMERATION_INFO *ei)) {
return false;
};
/**
* Configures any needed endpoint information for an interface.
* You must provide this in your driver.
* Executed when new devices are connected and OKtoEnumerate()
* returned true.
*
* @param ei
* @return zero on success
*/
virtual uint8_t SetInterface(NOTUSED(ENUMERATION_INFO *ei)) {
return UHS_HOST_ERROR_NOT_IMPLEMENTED;
};
/**
* Interface specific additional setup and enumeration that
* can't occur when the descriptor stream is open.
* Also used for collection of unclaimed interfaces, to link to the master.
*
* @return zero on success
*/
virtual uint8_t Finalize(void) {
return 0;
};
/**
* Executed after interface is finalized but, before polling has started.
*
* @return 0 on success
*/
virtual uint8_t OnStart(void) {
return 0;
};
/**
* Start interface polling
* @return
*/
virtual uint8_t Start(void) {
uint8_t rcode = OnStart();
if(!rcode) bPollEnable = true;
return rcode;
};
/**
* Executed before anything else in Release().
*
*/
virtual void OnRelease(void) {
return;
};
/**
* Release resources when device is disconnected.
* Normally this does not need to be overridden.
*/
virtual void Release(void) {
OnRelease();
DriverDefaults();
return;
};
/**
* Executed After driver polls.
* Can be used when there is an important change detected during polling
* and you want to handle it elsewhere.
* Examples:
* Media status change for bulk, e.g. ready, not-ready, media changed, door opened.
* Button state/joystick position/etc changes on a HID device.
* Flow control status change on a communication device, e.g. CTS on serial
*/
virtual void OnPoll(void) {
return;
};
/**
* Poll interface driver. You should override this in your driver if you
* require polling faster or slower than every 100 milliseconds, or your
* driver requires special housekeeping.
*/
virtual void Poll() {
OnPoll();
qNextPollTime = millis() + 100;
};
virtual bool UHS_NI Polling(void) {
return bPollEnable;
}
/**
* This is only for a hub.
* @param port
*/
virtual void ResetHubPort(NOTUSED(uint8_t port)) {
return;
};
#if 0
/**
*
* @return true if this interface is Vendor Specific.
*/
virtual bool IsVSI() {
return false;
}
#endif
};
#if 0
/**
*
* Vendor Specific interface class.
* This is used by a partner interface.
* It can also be used to force-enumerate an interface that
* can use this interface directly.
* You can also add an instance of this class within the interface constructor
* if you expect the interface.
*
* If this is not needed, it may be removed. Nothing I have written needs this.
* Let me know if it is not required, then IsVSI method can also be shit-canned.
* -- AJK
*/
class UHS_VSI : public UHS_USBInterface {
public:
volatile UHS_EpInfo epInfo[1];
volatile ENUMERATION_INFO eInfo;
UHS_VSI(UHS_USB_HOST_BASE *p);
bool OKtoEnumerate(ENUMERATION_INFO *ei);
uint8_t SetInterface(ENUMERATION_INFO *ei);
virtual void DriverDefaults(void);
virtual void Release(void);
uint8_t GetAddress(void) {
return bAddress;
};
virtual bool IsVSI() {
return true;
}
};
#endif
#endif //_USBHOST_H_
#endif

129
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/UHS_util_INLINE.h Normal file
View file

@ -0,0 +1,129 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if defined(LOAD_USB_HOST_SYSTEM) && !defined(USB_HOST_SYSTEM_UTIL_LOADED)
#define USB_HOST_SYSTEM_UTIL_LOADED
// 0x80 is the default (i.e. trace) to turn off set this global to something lower.
// this allows for 126 other debugging levels.
// TO-DO: Allow assignment to a different serial port by software
int UsbDEBUGlvl = 0x80;
void E_Notifyc(char c, int lvl) {
if(UsbDEBUGlvl < lvl) return;
#if defined(ARDUINO) && ARDUINO >=100
USB_HOST_SERIAL.print(c);
#else
USB_HOST_SERIAL.print(c, BYTE);
#endif
//USB_HOST_SERIAL.flush();
}
void E_Notify(char const * msg, int lvl) {
if(UsbDEBUGlvl < lvl) return;
if(!msg) return;
char c;
while((c = pgm_read_byte(msg++))) E_Notifyc(c, lvl);
}
void E_NotifyStr(char const * msg, int lvl) {
if(UsbDEBUGlvl < lvl) return;
if(!msg) return;
char c;
while((c = *msg++)) E_Notifyc(c, lvl);
}
void E_Notify(uint8_t b, int lvl) {
if(UsbDEBUGlvl < lvl) return;
#if defined(ARDUINO) && ARDUINO >=100
USB_HOST_SERIAL.print(b);
#else
USB_HOST_SERIAL.print(b, DEC);
#endif
}
void E_Notify(double d, int lvl) {
if(UsbDEBUGlvl < lvl) return;
USB_HOST_SERIAL.print(d);
}
#ifdef DEBUG_USB_HOST
void NotifyFailGetDevDescr(void) {
Notify(PSTR("\r\ngetDevDescr "), 0x80);
}
void NotifyFailSetDevTblEntry(void) {
Notify(PSTR("\r\nsetDevTblEn "), 0x80);
}
void NotifyFailGetConfDescr(void) {
Notify(PSTR("\r\ngetConf "), 0x80);
}
void NotifyFailSetConfDescr(void) {
Notify(PSTR("\r\nsetConf "), 0x80);
}
void NotifyFailGetDevDescr(uint8_t reason) {
NotifyFailGetDevDescr();
NotifyFail(reason);
}
void NotifyFailSetDevTblEntry(uint8_t reason) {
NotifyFailSetDevTblEntry();
NotifyFail(reason);
}
void NotifyFailGetConfDescr(uint8_t reason) {
NotifyFailGetConfDescr();
NotifyFail(reason);
}
void NotifyFailSetConfDescr(uint8_t reason) {
NotifyFailSetConfDescr();
NotifyFail(reason);
}
void NotifyFailUnknownDevice(uint16_t VID, uint16_t PID) {
Notify(PSTR("\r\nUnknown Device Connected - VID: "), 0x80);
D_PrintHex<uint16_t > (VID, 0x80);
Notify(PSTR(" PID: "), 0x80);
D_PrintHex<uint16_t > (PID, 0x80);
}
void NotifyFail(uint8_t rcode) {
D_PrintHex<uint8_t > (rcode, 0x80);
Notify(PSTR("\r\n"), 0x80);
}
#endif
#else
#error "Never include UHS_util_INLINE.h, include UHS_host.h instead"
#endif

226
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/USB_HOST_SHIELD/UHS_max3421e.h Normal file
View file

@ -0,0 +1,226 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This software may be distributed and modified under the terms of the GNU
General Public License version 2 (GPL2) as published by the Free Software
Foundation and appearing in the file GPL2.TXT included in the packaging of
this file. Please note that GPL2 Section 2[b] requires that all works based
on this software must also be made publicly available under the terms of
the GPL2 ("Copyleft").
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if !defined(USB_HOST_SHIELD_H) || defined(_max3421e_h_)
#error "Never include UHS_max3421e.h directly; include USB_HOST_SHIELD.h instead"
#else
#define _max3421e_h_
/* MAX3421E register/bit names and bitmasks */
#define SE0 0
#define SE1 1
#define FSHOST 2
#define LSHOST 3
/* MAX3421E command byte format: rrrrr0wa where 'r' is register number */
//
// MAX3421E Registers in HOST mode.
//
#define rRCVFIFO 0x08 // Receive FIFO Register
#define rSNDFIFO 0x10 // Send FIFO Register
#define rSUDFIFO 0x20 // Set Up Data FIFO Register
#define rRCVBC 0x30 // Receive FIFO Byte Count Register
#define rSNDBC 0x38 // Send FIFO Byte Count Register
// USB Interrupt Request Status (USBIRQ)
#define rUSBIRQ 0x68 // USB Interrupt Request Register
#define bmVBUSIRQ 0x40 // Vbus Present Interrupt Request
#define bmNOVBUSIRQ 0x20 // Vbus Absent Interrupt Request
#define bmOSCOKIRQ 0x01 // Oscillator OK Interrupt Request
// USB Interrupt Request Control (USBIEN)
#define rUSBIEN 0x70 // USB Interrupt Request Enable Register
#define bmVBUSIE bmVBUSIRQ // Vbus Present Interrupt Request Enable
#define bmNOVBUSIE bmNOVBUSIRQ // Vbus Absent Interrupt Request Enable
#define bmOSCOKIE bmOSCOKIRQ // Oscillator OK Interrupt Request Enable
// (USBCTL)
#define rUSBCTL 0x78 //15<<3
#define bmCHIPRES 0x20 //b5
#define bmPWRDOWN 0x10 //b4
// (CPUCTL)
#define rCPUCTL 0x80 //16<<3
#define bmPUSLEWID1 0x80 //b7
#define bmPULSEWID0 0x40 //b6
#define bmIE 0x01 //b0
// bmPUSLEWID1 bmPULSEWID0 Pulse width
// 0 0 10.6uS
// 0 1 5.3uS
// 1 0 2.6uS
// 1 1 1.3uS
#define PUSLEWIDTH10_6 (0)
#define PUSLEWIDTH5_3 (bmPULSEWID0)
#define PUSLEWIDTH2_6 (bmPUSLEWID1)
#define PUSLEWIDTH1_3 (bmPULSEWID0 | bmPUSLEWID1)
// (PINCTL)
#define rPINCTL 0x88 //17<<3
#define bmFDUPSPI 0x10 //b4
#define bmINTLEVEL 0x08 //b3
#define bmPOSINT 0x04 //b2
#define bmGPXB 0x02 //b1
#define bmGPXA 0x01 //b0
// GPX pin selections
#define GPX_OPERATE 0x00 //
#define GPX_VBDET 0x01 //
#define GPX_BUSACT 0x02 //
#define GPX_SOF 0x03 //
#define rREVISION 0x90 //18<<3
// (IOPINS1)
#define rIOPINS1 0xa0 //20<<3
#define bmGPOUT0 0x01 //
#define bmGPOUT1 0x02 //
#define bmGPOUT2 0x04 //
#define bmGPOUT3 0x08 //
#define bmGPIN0 0x10 //
#define bmGPIN1 0x20 //
#define bmGPIN2 0x40 //
#define bmGPIN3 0x80 //
// (IOPINS2)
#define rIOPINS2 0xa8 //21<<3
#define bmGPOUT4 0x01 //
#define bmGPOUT5 0x02 //
#define bmGPOUT6 0x04 //
#define bmGPOUT7 0x08 //
#define bmGPIN4 0x10 //
#define bmGPIN5 0x20 //
#define bmGPIN6 0x40 //
#define bmGPIN7 0x80 //
// (GPINIRQ)
#define rGPINIRQ 0xb0 //22<<3
#define bmGPINIRQ0 0x01 //
#define bmGPINIRQ1 0x02 //
#define bmGPINIRQ2 0x04 //
#define bmGPINIRQ3 0x08 //
#define bmGPINIRQ4 0x10 //
#define bmGPINIRQ5 0x20 //
#define bmGPINIRQ6 0x40 //
#define bmGPINIRQ7 0x80 //
// (GPINIEN)
#define rGPINIEN 0xb8 //23<<3
#define bmGPINIEN0 0x01 //
#define bmGPINIEN1 0x02 //
#define bmGPINIEN2 0x04 //
#define bmGPINIEN3 0x08 //
#define bmGPINIEN4 0x10 //
#define bmGPINIEN5 0x20 //
#define bmGPINIEN6 0x40 //
#define bmGPINIEN7 0x80 //
// (GPINPOL)
#define rGPINPOL 0xc0 //24<<3
#define bmGPINPOL0 0x01 //
#define bmGPINPOL1 0x02 //
#define bmGPINPOL2 0x04 //
#define bmGPINPOL3 0x08 //
#define bmGPINPOL4 0x10 //
#define bmGPINPOL5 0x20 //
#define bmGPINPOL6 0x40 //
#define bmGPINPOL7 0x80 //
//
// If any data transfer errors occur, the HXFRDNIRQ asserts, while the RCVDAVIRQ does not.
//
// The CPU clears the SNDBAVIRQ by writing the SNDBC register.
// The CPU should never directly clear the SNDBAVIRQ bit.
// Host Interrupt Request Status (HIRQ)
#define rHIRQ 0xc8 // Host Interrupt Request Register
#define bmBUSEVENTIRQ 0x01 // BUS Reset Done or BUS Resume Interrupt Request
#define bmRWUIRQ 0x02 // Remote Wakeup Interrupt Request
#define bmRCVDAVIRQ 0x04 // Receive FIFO Data Available Interrupt Request
#define bmSNDBAVIRQ 0x08 // Send Buffer Available Interrupt Request
#define bmSUSDNIRQ 0x10 // Suspend operation Done Interrupt Request
#define bmCONDETIRQ 0x20 // Peripheral Connect/Disconnect Interrupt Request
#define bmFRAMEIRQ 0x40 // Frame Generator Interrupt Request
#define bmHXFRDNIRQ 0x80 // Host Transfer Done Interrupt Request
// IRQs that are OK for the CPU to clear
#define ICLRALLBITS (bmBUSEVENTIRQ | bmRWUIRQ | bmRCVDAVIRQ | bmSUSDNIRQ | bmCONDETIRQ | bmFRAMEIRQ | bmHXFRDNIRQ)
// Host Interrupt Request Control (HIEN)
#define rHIEN 0xd0 //
#define bmBUSEVENTIE bmBUSEVENTIRQ // BUS Reset Done or BUS Resume Interrupt Request Enable
#define bmRWUIE bmRWUIRQ // Remote Wakeup Interrupt Request Enable
#define bmRCVDAVIE bmRCVDAVIRQ // Receive FIFO Data Available Interrupt Request Enable
#define bmSNDBAVIE bmSNDBAVIRQ // Send Buffer Available Interrupt Request Enable
#define bmSUSDNIE bmSUSDNIRQ // Suspend operation Done Interrupt Request Enable
#define bmCONDETIE bmCONDETIRQ // Peripheral Connect/Disconnect Interrupt Request Enable
#define bmFRAMEIE bmFRAMEIRQ // Frame Generator Interrupt Request Enable
#define bmHXFRDNIE bmHXFRDNIRQ // Host Transfer Done Interrupt Request Enable
// (MODE))
#define rMODE 0xd8 //27<<3
#define bmHOST 0x01 //
#define bmLOWSPEED 0x02 //
#define bmHUBPRE 0x04 //
#define bmSOFKAENAB 0x08 //
#define bmSEPIRQ 0x10 //
#define bmDELAYISO 0x20 //
#define bmDMPULLDN 0x40 //
#define bmDPPULLDN 0x80 //
#define rPERADDR 0xe0 //28<<3
// (HCTL)
#define rHCTL 0xe8 //29<<3
#define bmBUSRST 0x01 //
#define bmFRMRST 0x02 //
#define bmSAMPLEBUS 0x04 //
#define bmSIGRSM 0x08 //
#define bmRCVTOG0 0x10 //
#define bmRCVTOG1 0x20 //
#define bmSNDTOG0 0x40 //
#define bmSNDTOG1 0x80 //
// Host transfer (HXFR)
#define rHXFR 0xf0 //30<<3
/* Host transfer token values for writing the HXFR register (R30) */
/* OR this bit field with the endpoint number in bits 3:0 */
#define MAX3421E_tokSETUP 0x10 // HS=0, ISO=0, OUTNIN=0, SETUP=1
#define MAX3421E_tokIN 0x00 // HS=0, ISO=0, OUTNIN=0, SETUP=0
#define MAX3421E_tokOUT 0x20 // HS=0, ISO=0, OUTNIN=1, SETUP=0
#define MAX3421E_tokINHS 0x80 // HS=1, ISO=0, OUTNIN=0, SETUP=0
#define MAX3421E_tokOUTHS 0xA0 // HS=1, ISO=0, OUTNIN=1, SETUP=0
#define MAX3421E_tokISOIN 0x40 // HS=0, ISO=1, OUTNIN=0, SETUP=0
#define MAX3421E_tokISOOUT 0x60 // HS=0, ISO=1, OUTNIN=1, SETUP=0
// (HRSL)
#define rHRSL 0xf8 //31<<3
#define bmRCVTOGRD 0x10 //
#define bmSNDTOGRD 0x20 //
#define bmKSTATUS 0x40 //
#define bmJSTATUS 0x80 //
#define bmSE0 0x00 //SE0 - disconnect state
#define bmSE1 0xc0 //SE1 - illegal state
#define MODE_FS_HOST (bmDPPULLDN|bmDMPULLDN|bmHOST|bmSOFKAENAB)
#define MODE_LS_HOST (bmDPPULLDN|bmDMPULLDN|bmHOST|bmLOWSPEED|bmSOFKAENAB)
#endif //_max3421e_h_

519
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/USB_HOST_SHIELD/USB_HOST_SHIELD.h Normal file
View file

@ -0,0 +1,519 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This software may be distributed and modified under the terms of the GNU
General Public License version 2 (GPL2) as published by the Free Software
Foundation and appearing in the file GPL2.TXT included in the packaging of
this file. Please note that GPL2 Section 2[b] requires that all works based
on this software must also be made publicly available under the terms of
the GPL2 ("Copyleft").
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#ifndef USB_HOST_SHIELD_H
#define USB_HOST_SHIELD_H
// uncomment to get 'printf' console debugging. NOT FOR UNO!
//#define DEBUG_PRINTF_EXTRA_HUGE_USB_HOST_SHIELD
#ifdef LOAD_USB_HOST_SHIELD
#include "UHS_max3421e.h"
#include <SPI.h>
#if !defined(SPI_HAS_TRANSACTION)
#error "Your SPI library installation is too old."
#else
#if !defined(SPI_ATOMIC_VERSION)
#warning "Your SPI library installation lacks 'SPI_ATOMIC_VERSION'. Please complain to the maintainer."
#elif SPI_ATOMIC_VERSION < 1
#error "Your SPI library installation is too old."
#endif
#endif
#if DEBUG_PRINTF_EXTRA_HUGE
#ifdef DEBUG_PRINTF_EXTRA_HUGE_USB_HOST_SHIELD
#define MAX_HOST_DEBUG(...) printf_P(__VA_ARGS__)
#else
#define MAX_HOST_DEBUG(...) VOID0
#endif
#else
#define MAX_HOST_DEBUG(...) VOID0
#endif
#if !defined(USB_HOST_SHIELD_USE_ISR)
#if defined(USE_MULTIPLE_APP_API)
#define USB_HOST_SHIELD_USE_ISR 0
#else
#define USB_HOST_SHIELD_USE_ISR 1
#endif
#else
#define USB_HOST_SHIELD_USE_ISR 1
#endif
#if !USB_HOST_SHIELD_USE_ISR
#error NOISR Polled mode _NOT SUPPORTED YET_
//
// Polled defaults
//
#if defined(BOARD_BLACK_WIDDOW)
#define UHS_MAX3421E_SS_ 6
#define UHS_MAX3421E_INT_ 3
#elif defined(CORE_TEENSY) && (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__))
#if EXT_RAM
// Teensy++ 2.0 with XMEM2
#define UHS_MAX3421E_SS_ 20
#define UHS_MAX3421E_INT_ 7
#else
#define UHS_MAX3421E_SS_ 9
#define UHS_MAX3421E_INT_ 8
#endif
#define UHS_MAX3421E_SPD
#elif defined(ARDUINO_AVR_ADK)
#define UHS_MAX3421E_SS_ 53
#define UHS_MAX3421E_INT_ 54
#elif defined(ARDUINO_AVR_BALANDUINO)
#define UHS_MAX3421E_SS_ 20
#define UHS_MAX3421E_INT_ 19
#else
#define UHS_MAX3421E_SS_ 10
#define UHS_MAX3421E_INT_ 9
#endif
#else
#if defined(ARDUINO_ARCH_PIC32)
// PIC32 only allows edge interrupts, isn't that lovely? We'll emulate it...
#if CHANGE < 2
#error core too old.
#endif
#define IRQ_IS_EDGE 0
#ifndef digitalPinToInterrupt
// great, this isn't implemented.
#warning digitalPinToInterrupt is not defined, complain here https://github.com/chipKIT32/chipKIT-core/issues/114
#if defined(_BOARD_UNO_) || defined(_BOARD_UC32_)
#define digitalPinToInterrupt(p) ((p) == 2 ? 1 : ((p) == 7 ? 2 : ((p) == 8 ? 3 : ((p) == 35 ? 4 : ((p) == 38 ? 0 : NOT_AN_INTERRUPT)))))
#warning digitalPinToInterrupt is now defined until this is taken care of.
#else
#error digitalPinToInterrupt not defined for your board, complain here https://github.com/chipKIT32/chipKIT-core/issues/114
#endif
#endif
#else
#define IRQ_IS_EDGE 0
#endif
// More stupidity from our friends @ Sony...
#if defined(ARDUINO_spresense_ast)
#if !defined(NOT_AN_INTERRUPT)
#define NOT_AN_INTERRUPT -1
#endif
#endif
// SAMD uses an enum for this instead of a define. Isn't that just dandy?
#if !defined(NOT_AN_INTERRUPT) && !defined(ARDUINO_ARCH_SAMD)
#warning NOT_AN_INTERRUPT not defined, possible problems ahead.
#warning If NOT_AN_INTERRUPT is an enum or something else, complain to UHS30 developers on github.
#warning Otherwise complain to your board core developer/maintainer.
#define NOT_AN_INTERRUPT -1
#endif
//
// Interrupt defaults. Int0 or Int1
//
#ifdef BOARD_BLACK_WIDDOW
#error "HELP! Please send us an email, I don't know the values for Int0 and Int1 on the Black Widow board!"
#elif defined(ARDUINO_AVR_ADK)
#define UHS_MAX3421E_SS_ 53
#define UHS_MAX3421E_INT_ 54
#elif defined(ARDUINO_spresense_ast)
#define UHS_MAX3421E_SS_ 21
#define UHS_MAX3421E_INT_ 20
#define SPIclass SPI5
//#define UHS_MAX3421E_SPD 100000
#elif defined(CORE_TEENSY) && (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__))
// TO-DO!
#if EXT_RAM
// Teensy++ 2.0 with XMEM2
#define UHS_MAX3421E_SS_ 20
#define UHS_MAX3421E_INT_ 7
#else
#define UHS_MAX3421E_SS_ 9
#define UHS_MAX3421E_INT_ 8
#endif
#elif defined(ARDUINO_AVR_BALANDUINO)
#error "ISR mode is currently not supported on the Balanduino. Please set USB_HOST_SHIELD_USE_ISR to 0."
#else
#define UHS_MAX3421E_SS_ 10
#ifdef __AVR__
#if defined(__AVR_ATmega32U4__)
#define INT_FOR_PIN2 1
#define INT_FOR_PIN3 0
#else
// Everybody else???
#define INT_FOR_PIN2 0
#define INT_FOR_PIN3 1
#endif
#define UHS_MAX3421E_INT_ 3
#else
// Non-avr
#if defined(ARDUINO_ARCH_PIC32)
// UNO32 External Interrupts:
// Pin 38 (INT0), Pin 2 (INT1), Pin 7 (INT2), Pin 8 (INT3), Pin 35 (INT4)
#define UHS_MAX3421E_INT_ 7
#else
#define UHS_MAX3421E_INT_ 9
#endif
#endif
#endif
#endif
#if defined(NO_AUTO_SPEED)
// Ugly details section...
// MAX3421E characteristics
// SPI Serial - Clock Input. An external SPI master supplies SCLK with frequencies up to 26MHz. The
// logic level is referenced to the voltage on VL. Data is clocked into the SPI slave inter face on the
// rising edge of SCLK. Data is clocked out of the SPI slave interface on the falling edge of SCLK.
// Serial Clock (SCLK) Period 38.4ns minimum. 17ns minimum pulse width. VL >2.5V
// SCLK Fall to MISO Propagation Delay 14.2ns
// SCLK Fall to MOSI Propagation Delay 14.2ns
// SCLK Fall to MOSI Drive 3.5ns
// Theoretical deadline for reply 17.7ns
// 26MHz 38.4615ns period <-- MAX3421E theoretical maximum
#if !defined(UHS_MAX3421E_SPD)
#if defined(ARDUINO_SAMD_ZERO)
// Zero violates spec early, needs a long setup time, or doesn't like high latency.
#define UHS_MAX3421E_SPD 10000000
#elif defined(ARDUINO_ARCH_PIC32)
// PIC MX 5/6/7 characteristics
// 25MHZ 40ns period <-- PIC MX 5/6/7 theoretical maximum
// pulse width minimum Tsclk/2ns
// Trise/fall 10ns maximum. 5ns is typical but not guaranteed.
// Tsetup minimum for MISO 10ns.
// We are in violation by 7.7ns @ 25MHz due to latency alone.
// Even reading at end of data cycle, we only have a 2.3ns window.
// This is too narrow to to compensate for capacitance, trace lengths, and noise.
// 17.7ns + 10ns = 27.7ns
// 18MHz fits and has enough slack time to compensate for capacitance, trace lengths, and noise.
// For high speeds the SMP bit is recommended too, which samples at the end instead of the middle.
// 20Mhz seems to work.
#define UHS_MAX3421E_SPD 20000000
#else
#define UHS_MAX3421E_SPD 25000000
#endif
#endif
#else
// We start at 25MHz, and back down until hardware can take it.
// Of course, SPI library can adjust this for us too.
// Why not 26MHz? Because I have not found any MCU board that
// can actually go that fast without problems.
// Could be a shield limitation too.
#if !defined(UHS_MAX3421E_SPD)
#define UHS_MAX3421E_SPD 25000000
#endif
#endif
#ifndef UHS_MAX3421E_INT
#define UHS_MAX3421E_INT UHS_MAX3421E_INT_
#endif
#ifndef UHS_MAX3421E_SS
#define UHS_MAX3421E_SS UHS_MAX3421E_SS_
#endif
// NOTE: On the max3421e the irq enable and irq bits are in the same position.
// IRQs used if CPU polls
#define ENIBITSPOLLED (bmCONDETIE | bmBUSEVENTIE | bmFRAMEIE)
// IRQs used if CPU is interrupted
#define ENIBITSISR (bmCONDETIE | bmBUSEVENTIE | bmFRAMEIE /* | bmRCVDAVIRQ | bmSNDBAVIRQ | bmHXFRDNIRQ */ )
#if !USB_HOST_SHIELD_USE_ISR
#define IRQ_CHECK_MASK (ENIBITSPOLLED & ICLRALLBITS)
#define IRQ_IS_EDGE 0
#else
#define IRQ_CHECK_MASK (ENIBITSISR & ICLRALLBITS)
#endif
#if IRQ_IS_EDGE
// Note: UNO32 Interrupts can only be RISING, or FALLING.
// This poses an interesting problem, since we want to use a LOW level.
// The MAX3421E provides for pulse width control for an IRQ.
// We do need to watch the timing on this, as a second IRQ could cause
// a missed IRQ, since we read the level of the line to check if the IRQ
// is actually for this chip. The only other alternative is to add a capacitor
// and an NPN transistor, and use two lines. We can try this first, though.
// Worse case, we can ignore reading the pin for verification on UNO32.
// Too bad there is no minimum low width setting.
//
// Single Clear First Second Clear first Clear last
// IRQ Single IRQ IRQ Second active pending IRQ
// | | | | | |
// V V V V V V
// _____ _________ _ _ _______
// |______| |______| |______| |______________|
//
#define IRQ_SENSE FALLING
#if defined(ARDUINO_ARCH_PIC32)
//#define bmPULSEWIDTH PUSLEWIDTH10_6
#define bmPULSEWIDTH 0
#define bmIRQ_SENSE 0
#else
#define bmPULSEWIDTH PUSLEWIDTH1_3
#define bmIRQ_SENSE 0
#endif
#else
#if !defined(IRQ_SENSE)
#define IRQ_SENSE LOW
#endif
#if !defined(bmPULSEWIDTH)
#define bmPULSEWIDTH 0
#endif
#if !defined(bmIRQ_SENSE)
#define bmIRQ_SENSE bmINTLEVEL
#endif
#endif
class MAX3421E_HOST :
public UHS_USB_HOST_BASE
#if defined(SWI_IRQ_NUM)
, public dyn_SWI
#endif
{
// TO-DO: move these into the parent class.
volatile uint8_t vbusState;
volatile uint16_t sof_countdown;
// TO-DO: pack into a struct/union and use one byte
volatile bool busevent;
volatile bool sofevent;
volatile bool counted;
volatile bool condet;
volatile bool doingreset;
#ifdef USB_HOST_MANUAL_POLL
volatile bool frame_irq_enabled = false;
bool enable_frame_irq(bool enable) {
const bool prev_state = frame_irq_enabled;
if(prev_state != enable) {
if(enable)
regWr(rHIEN, regRd(rHIEN) | bmFRAMEIE);
else
regWr(rHIEN, regRd(rHIEN) & ~bmFRAMEIE);
frame_irq_enabled = enable;
}
return prev_state;
}
#endif
public:
SPISettings MAX3421E_SPI_Settings;
uint8_t ss_pin;
uint8_t irq_pin;
// Will use the defaults UHS_MAX3421E_SS, UHS_MAX3421E_INT and speed
UHS_NI MAX3421E_HOST(void) {
sof_countdown = 0;
busevent = false;
doingreset = false;
sofevent = false;
condet = false;
ss_pin = UHS_MAX3421E_SS;
irq_pin = UHS_MAX3421E_INT;
MAX3421E_SPI_Settings = SPISettings(UHS_MAX3421E_SPD, MSBFIRST, SPI_MODE0);
hub_present = 0;
};
// Will use user supplied pins, and UHS_MAX3421E_SPD
UHS_NI MAX3421E_HOST(uint8_t pss, uint8_t pirq) {
sof_countdown = 0;
busevent = false;
doingreset = false;
sofevent = false;
condet = false;
ss_pin = pss;
irq_pin = pirq;
MAX3421E_SPI_Settings = SPISettings(UHS_MAX3421E_SPD, MSBFIRST, SPI_MODE0);
hub_present = 0;
};
// Will use user supplied pins, and speed
UHS_NI MAX3421E_HOST(uint8_t pss, uint8_t pirq, uint32_t pspd) {
sof_countdown = 0;
doingreset = false;
busevent = false;
sofevent = false;
condet = false;
ss_pin = pss;
irq_pin = pirq;
MAX3421E_SPI_Settings = SPISettings(pspd, MSBFIRST, SPI_MODE0);
hub_present = 0;
};
virtual bool UHS_NI sof_delay(uint16_t x) {
#ifdef USB_HOST_MANUAL_POLL
const bool saved_irq_state = enable_frame_irq(true);
#endif
sof_countdown = x;
while((sof_countdown != 0) && !condet) {
SYSTEM_OR_SPECIAL_YIELD();
#if !USB_HOST_SHIELD_USE_ISR
Task();
#endif
}
#ifdef USB_HOST_MANUAL_POLL
enable_frame_irq(saved_irq_state);
#endif
// Serial.println("...Wake");
return (!condet);
};
virtual UHS_EpInfo *ctrlReqOpen(uint8_t addr, uint64_t Request, uint8_t* dataptr);
virtual void UHS_NI vbusPower(VBUS_t state) {
regWr(rPINCTL, (bmFDUPSPI | bmIRQ_SENSE) | (uint8_t)(state));
};
void UHS_NI Task(void);
virtual uint8_t SetAddress(uint8_t addr, uint8_t ep, UHS_EpInfo **ppep, uint16_t &nak_limit);
virtual uint8_t OutTransfer(UHS_EpInfo *pep, uint16_t nak_limit, uint16_t nbytes, uint8_t *data);
virtual uint8_t InTransfer(UHS_EpInfo *pep, uint16_t nak_limit, uint16_t *nbytesptr, uint8_t *data);
virtual uint8_t ctrlReqClose(UHS_EpInfo *pep, uint8_t bmReqType, uint16_t left, uint16_t nbytes, uint8_t *dataptr);
virtual uint8_t ctrlReqRead(UHS_EpInfo *pep, uint16_t *left, uint16_t *read, uint16_t nbytes, uint8_t *dataptr);
virtual uint8_t dispatchPkt(uint8_t token, uint8_t ep, uint16_t nak_limit);
void UHS_NI ReleaseChildren(void) {
for(uint8_t i = 0; i < UHS_HOST_MAX_INTERFACE_DRIVERS; i++)
if(devConfig[i])
devConfig[i]->Release();
hub_present = 0;
};
virtual bool IsHub(uint8_t klass) {
if(klass == UHS_USB_CLASS_HUB) {
hub_present = bmHUBPRE;
return true;
}
return false;
};
virtual void VBUS_changed(void);
virtual void UHS_NI doHostReset(void) {
#if USB_HOST_SHIELD_USE_ISR
// Enable interrupts
noInterrupts();
#endif
doingreset = true;
busevent = true;
regWr(rHIRQ, bmBUSEVENTIRQ); // see data sheet.
regWr(rHCTL, bmBUSRST); //issue bus reset
#if USB_HOST_SHIELD_USE_ISR
DDSB();
// Enable interrupts
interrupts();
#endif
while(busevent) {
DDSB();
SYSTEM_OR_SPECIAL_YIELD();
}
#endif
#if USB_HOST_SHIELD_USE_ISR
// Enable interrupts
noInterrupts();
#endif
#ifdef USB_HOST_MANUAL_POLL
enable_frame_irq(true);
#endif
sofevent = true;
#if USB_HOST_SHIELD_USE_ISR
DDSB();
// Enable interrupts
interrupts();
#endif
// Wait for SOF
while(sofevent) {
}
#if USB_HOST_SHIELD_USE_ISR
// Enable interrupts
noInterrupts();
#endif
doingreset = false;
#if USB_HOST_SHIELD_USE_ISR
DDSB();
// Enable interrupts
interrupts();
};
int16_t UHS_NI Init(int16_t mseconds);
int16_t UHS_NI Init(void) {
return Init(INT16_MIN);
};
void ISRTask(void);
void ISRbottom(void);
void busprobe(void);
uint16_t reset(void);
// MAX3421e specific
void regWr(uint8_t reg, uint8_t data);
void gpioWr(uint8_t data);
uint8_t regRd(uint8_t reg);
uint8_t gpioRd(void);
uint8_t* bytesWr(uint8_t reg, uint8_t nbytes, uint8_t* data_p);
uint8_t* bytesRd(uint8_t reg, uint8_t nbytes, uint8_t* data_p);
// ARM/NVIC specific, used to emulate reentrant ISR.
#if defined(SWI_IRQ_NUM)
void dyn_SWISR(void) {
ISRbottom();
};
#endif
virtual void UHS_NI suspend_host(void) {
// Used on MCU that lack control of IRQ priority (AVR).
// Suspends ISRs, for critical code. IRQ will be serviced after it is resumed.
// NOTE: you must track the state yourself!
#if defined(__AVR__)
noInterrupts();
detachInterrupt(UHS_GET_DPI(irq_pin));
interrupts();
#endif
};
virtual void UHS_NI resume_host(void);
};
#if !defined(SPIclass)
#define SPIclass SPI
#endif
#if !defined(USB_HOST_SHIELD_LOADED)
#include "USB_HOST_SHIELD_INLINE.h"
#endif
#else
#error "define LOAD_USB_HOST_SHIELD in your sketch, never include USB_HOST_SHIELD.h in a driver."
#endif
#endif /* USB_HOST_SHIELD_H */

1003
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/USB_HOST_SHIELD/USB_HOST_SHIELD_INLINE.h Normal file
View file

@ -0,0 +1,1003 @@
/* Copyright (C) 2015-2016 Andrew J. Kroll
and
Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
This software may be distributed and modified under the terms of the GNU
General Public License version 2 (GPL2) as publishe7d by the Free Software
Foundation and appearing in the file GPL2.TXT included in the packaging of
this file. Please note that GPL2 Section 2[b] requires that all works based
on this software must also be made publicly available under the terms of
the GPL2 ("Copyleft").
Contact information
-------------------
Circuits At Home, LTD
Web : http://www.circuitsathome.com
e-mail : support@circuitsathome.com
*/
#if defined(USB_HOST_SHIELD_H) && !defined(USB_HOST_SHIELD_LOADED)
#define USB_HOST_SHIELD_LOADED
#include <Arduino.h>
#if !defined(digitalPinToInterrupt)
#error digitalPinToInterrupt not defined, complain to your board maintainer.
#endif
#if USB_HOST_SHIELD_USE_ISR
// allow two slots. this makes the maximum allowed shield count TWO
// for AVRs this is limited to pins 2 and 3 ONLY
// for all other boards, one odd and one even pin number is allowed.
static MAX3421E_HOST *ISReven;
static MAX3421E_HOST *ISRodd;
static void UHS_NI call_ISReven(void) {
ISReven->ISRTask();
}
static void UHS_NI call_ISRodd(void) {
UHS_PIN_WRITE(LED_BUILTIN, HIGH);
ISRodd->ISRTask();
}
#endif
void UHS_NI MAX3421E_HOST::resume_host(void) {
// Used on MCU that lack control of IRQ priority (AVR).
// Resumes ISRs.
// NOTE: you must track the state yourself!
#if defined(__AVR__)
noInterrupts();
if(irq_pin & 1) {
ISRodd = this;
attachInterrupt(UHS_GET_DPI(irq_pin), call_ISRodd, IRQ_SENSE);
} else {
ISReven = this;
attachInterrupt(UHS_GET_DPI(irq_pin), call_ISReven, IRQ_SENSE);
}
interrupts();
#endif
}
/* write single byte into MAX3421e register */
void UHS_NI MAX3421E_HOST::regWr(uint8_t reg, uint8_t data) {
SPIclass.beginTransaction(MAX3421E_SPI_Settings);
MARLIN_UHS_WRITE_SS(LOW);
SPIclass.transfer(reg | 0x02);
SPIclass.transfer(data);
MARLIN_UHS_WRITE_SS(HIGH);
SPIclass.endTransaction();
}
/* multiple-byte write */
/* returns a pointer to memory position after last written */
uint8_t* UHS_NI MAX3421E_HOST::bytesWr(uint8_t reg, uint8_t nbytes, uint8_t* data_p) {
SPIclass.beginTransaction(MAX3421E_SPI_Settings);
MARLIN_UHS_WRITE_SS(LOW);
SPIclass.transfer(reg | 0x02);
//printf("%2.2x :", reg);
while(nbytes) {
SPIclass.transfer(*data_p);
//printf("%2.2x ", *data_p);
nbytes--;
data_p++; // advance data pointer
}
MARLIN_UHS_WRITE_SS(HIGH);
SPIclass.endTransaction();
//printf("\r\n");
return (data_p);
}
/* GPIO write */
/*GPIO byte is split between 2 registers, so two writes are needed to write one byte */
/* GPOUT bits are in the low nibble. 0-3 in IOPINS1, 4-7 in IOPINS2 */
void UHS_NI MAX3421E_HOST::gpioWr(uint8_t data) {
regWr(rIOPINS1, data);
data >>= 4;
regWr(rIOPINS2, data);
return;
}
/* single host register read */
uint8_t UHS_NI MAX3421E_HOST::regRd(uint8_t reg) {
SPIclass.beginTransaction(MAX3421E_SPI_Settings);
MARLIN_UHS_WRITE_SS(LOW);
SPIclass.transfer(reg);
uint8_t rv = SPIclass.transfer(0);
MARLIN_UHS_WRITE_SS(HIGH);
SPIclass.endTransaction();
return (rv);
}
/* multiple-byte register read */
/* returns a pointer to a memory position after last read */
uint8_t* UHS_NI MAX3421E_HOST::bytesRd(uint8_t reg, uint8_t nbytes, uint8_t* data_p) {
SPIclass.beginTransaction(MAX3421E_SPI_Settings);
MARLIN_UHS_WRITE_SS(LOW);
SPIclass.transfer(reg);
while(nbytes) {
*data_p++ = SPIclass.transfer(0);
nbytes--;
}
MARLIN_UHS_WRITE_SS(HIGH);
SPIclass.endTransaction();
return ( data_p);
}
/* GPIO read. See gpioWr for explanation */
/* GPIN pins are in high nibbles of IOPINS1, IOPINS2 */
uint8_t UHS_NI MAX3421E_HOST::gpioRd(void) {
uint8_t gpin = 0;
gpin = regRd(rIOPINS2); //pins 4-7
gpin &= 0xf0; //clean lower nibble
gpin |= (regRd(rIOPINS1) >> 4); //shift low bits and OR with upper from previous operation.
return ( gpin);
}
/* reset MAX3421E. Returns number of microseconds it took for PLL to stabilize after reset
or zero if PLL haven't stabilized in 65535 cycles */
uint16_t UHS_NI MAX3421E_HOST::reset(void) {
uint16_t i = 0;
// Initiate chip reset
regWr(rUSBCTL, bmCHIPRES);
regWr(rUSBCTL, 0x00);
int32_t now;
uint32_t expires = micros() + 65535;
// Enable full-duplex SPI so we can read rUSBIRQ
regWr(rPINCTL, bmFDUPSPI);
while((int32_t)(micros() - expires) < 0L) {
if((regRd(rUSBIRQ) & bmOSCOKIRQ)) {
break;
}
}
now = (int32_t)(micros() - expires);
if(now < 0L) {
i = 65535 + now; // Note this subtracts, as now is negative
}
return (i);
}
void UHS_NI MAX3421E_HOST::VBUS_changed(void) {
/* modify USB task state because Vbus changed or unknown */
uint8_t speed = 1;
//printf("\r\n\r\n\r\n\r\nSTATE %2.2x -> ", usb_task_state);
switch(vbusState) {
case LSHOST: // Low speed
speed = 0;
// Intentional fall-through
case FSHOST: // Full speed
// Start device initialization if we are not initializing
// Resets to the device cause an IRQ
// usb_task_state == UHS_USB_HOST_STATE_RESET_NOT_COMPLETE;
//if((usb_task_state & UHS_USB_HOST_STATE_MASK) != UHS_USB_HOST_STATE_DETACHED) {
ReleaseChildren();
if(!doingreset) {
if(usb_task_state == UHS_USB_HOST_STATE_RESET_NOT_COMPLETE) {
usb_task_state = UHS_USB_HOST_STATE_WAIT_BUS_READY;
} else if(usb_task_state != UHS_USB_HOST_STATE_WAIT_BUS_READY) {
usb_task_state = UHS_USB_HOST_STATE_DEBOUNCE;
}
}
sof_countdown = 0;
break;
case SE1: //illegal state
sof_countdown = 0;
doingreset = false;
ReleaseChildren();
usb_task_state = UHS_USB_HOST_STATE_ILLEGAL;
break;
case SE0: //disconnected
default:
sof_countdown = 0;
doingreset = false;
ReleaseChildren();
usb_task_state = UHS_USB_HOST_STATE_IDLE;
break;
}
usb_host_speed = speed;
//printf("0x%2.2x\r\n\r\n\r\n\r\n", usb_task_state);
return;
};
/**
* Probe bus to determine device presence and speed,
* then switch host to detected speed.
*/
void UHS_NI MAX3421E_HOST::busprobe(void) {
uint8_t bus_sample;
uint8_t tmpdata;
bus_sample = regRd(rHRSL); //Get J,K status
bus_sample &= (bmJSTATUS | bmKSTATUS); //zero the rest of the byte
switch(bus_sample) { //start full-speed or low-speed host
case(bmJSTATUS):
// Serial.println("J");
if((regRd(rMODE) & bmLOWSPEED) == 0) {
regWr(rMODE, MODE_FS_HOST); // start full-speed host
vbusState = FSHOST;
} else {
regWr(rMODE, MODE_LS_HOST); // start low-speed host
vbusState = LSHOST;
}
#ifdef USB_HOST_MANUAL_POLL
enable_frame_irq(true);
#endif
tmpdata = regRd(rMODE) | bmSOFKAENAB; // start SOF generation
regWr(rHIRQ, bmFRAMEIRQ); // see data sheet.
regWr(rMODE, tmpdata);
break;
case(bmKSTATUS):
// Serial.println("K");
if((regRd(rMODE) & bmLOWSPEED) == 0) {
regWr(rMODE, MODE_LS_HOST); // start low-speed host
vbusState = LSHOST;
} else {
regWr(rMODE, MODE_FS_HOST); // start full-speed host
vbusState = FSHOST;
}
#ifdef USB_HOST_MANUAL_POLL
enable_frame_irq(true);
#endif
tmpdata = regRd(rMODE) | bmSOFKAENAB; // start SOF generation
regWr(rHIRQ, bmFRAMEIRQ); // see data sheet.
regWr(rMODE, tmpdata);
break;
case(bmSE1): //illegal state
// Serial.println("I");
regWr(rMODE, bmDPPULLDN | bmDMPULLDN | bmHOST);
vbusState = SE1;
// sofevent = false;
break;
case(bmSE0): //disconnected state
// Serial.println("D");
regWr(rMODE, bmDPPULLDN | bmDMPULLDN | bmHOST);
vbusState = SE0;
// sofevent = false;
break;
}//end switch( bus_sample )
}
/**
* Initialize USB hardware, turn on VBUS
*
* @param mseconds Delay energizing VBUS after mseconds, A value of INT16_MIN means no delay.
* @return 0 on success, -1 on error
*/
int16_t UHS_NI MAX3421E_HOST::Init(int16_t mseconds) {
usb_task_state = UHS_USB_HOST_STATE_INITIALIZE; //set up state machine
// Serial.print("MAX3421E 'this' USB Host @ 0x");
// Serial.println((uint32_t)this, HEX);
// Serial.print("MAX3421E 'this' USB Host Address Pool @ 0x");
// Serial.println((uint32_t)GetAddressPool(), HEX);
Init_dyn_SWI();
UHS_printf_HELPER_init();
noInterrupts();
#ifdef ARDUINO_AVR_ADK
// For Mega ADK, which has a Max3421e on-board,
// set MAX_RESET to output mode, and then set it to HIGH
// PORTJ bit 2
if(irq_pin == 54) {
DDRJ |= 0x04; // output
PORTJ |= 0x04; // HIGH
}
#endif
SPIclass.begin();
#ifdef ARDUINO_AVR_ADK
if(irq_pin == 54) {
DDRE &= ~0x20; // input
PORTE |= 0x20; // pullup
} else
#endif
pinMode(irq_pin, INPUT_PULLUP);
//UHS_PIN_WRITE(irq_pin, HIGH);
pinMode(ss_pin, OUTPUT);
MARLIN_UHS_WRITE_SS(HIGH);
#ifdef USB_HOST_SHIELD_TIMING_PIN
pinMode(USB_HOST_SHIELD_TIMING_PIN, OUTPUT);
// My counter/timer can't work on an inverted gate signal
// so we gate using a high pulse -- AJK
UHS_PIN_WRITE(USB_HOST_SHIELD_TIMING_PIN, LOW);
#endif
interrupts();
#if USB_HOST_SHIELD_USE_ISR
int intr = digitalPinToInterrupt(irq_pin);
if(intr == NOT_AN_INTERRUPT) {
#if defined(ARDUINO_AVR_ADK)
if(irq_pin == 54)
intr = 6;
else
#endif
return (-2);
}
SPIclass.usingInterrupt(intr);
#else
SPIclass.usingInterrupt(255);
#endif
#if !defined(NO_AUTO_SPEED)
// test to get to reset acceptance.
uint32_t spd = UHS_MAX3421E_SPD;
again:
MAX3421E_SPI_Settings = SPISettings(spd, MSBFIRST, SPI_MODE0);
if(reset() == 0) {
MAX_HOST_DEBUG(PSTR("Fail SPI speed %lu\r\n"), spd);
if(spd > 1999999) {
spd -= 1000000;
goto again;
}
return (-1);
} else {
// reset passes, does 64k?
uint8_t sample_wr = 0;
uint8_t sample_rd = 0;
uint8_t gpinpol_copy = regRd(rGPINPOL);
for(uint16_t j = 0; j < 65535; j++) {
regWr(rGPINPOL, sample_wr);
sample_rd = regRd(rGPINPOL);
if(sample_rd != sample_wr) {
MAX_HOST_DEBUG(PSTR("Fail SPI speed %lu\r\n"), spd);
if(spd > 1999999) {
spd -= 1000000;
goto again;
}
return (-1);
}
sample_wr++;
}
regWr(rGPINPOL, gpinpol_copy);
}
MAX_HOST_DEBUG(PSTR("Pass SPI speed %lu\r\n"), spd);
#endif
if(reset() == 0) { //OSCOKIRQ hasn't asserted in time
MAX_HOST_DEBUG(PSTR("OSCOKIRQ hasn't asserted in time"));
return ( -1);
}
/* MAX3421E - full-duplex SPI, interrupt kind, vbus off */
regWr(rPINCTL, (bmFDUPSPI | bmIRQ_SENSE | GPX_VBDET));
// Delay a minimum of 1 second to ensure any capacitors are drained.
// 1 second is required to make sure we do not smoke a Microdrive!
if(mseconds != INT16_MIN) {
if(mseconds < 1000) mseconds = 1000;
delay(mseconds); // We can't depend on SOF timer here.
}
regWr(rMODE, bmDPPULLDN | bmDMPULLDN | bmHOST); // set pull-downs, Host
// Enable interrupts on the MAX3421e
regWr(rHIEN, IRQ_CHECK_MASK);
// Enable interrupt pin on the MAX3421e, set pulse width for edge
regWr(rCPUCTL, (bmIE | bmPULSEWIDTH));
/* check if device is connected */
regWr(rHCTL, bmSAMPLEBUS); // sample USB bus
while(!(regRd(rHCTL) & bmSAMPLEBUS)); //wait for sample operation to finish
busprobe(); //check if anything is connected
VBUS_changed();
// GPX pin on. This is done here so that a change is detected if we have a switch connected.
/* MAX3421E - full-duplex SPI, interrupt kind, vbus on */
regWr(rPINCTL, (bmFDUPSPI | bmIRQ_SENSE));
regWr(rHIRQ, bmBUSEVENTIRQ); // see data sheet.
regWr(rHCTL, bmBUSRST); // issue bus reset to force generate yet another possible IRQ
#if USB_HOST_SHIELD_USE_ISR
// Attach ISR to service IRQ from MAX3421e
noInterrupts();
if(irq_pin & 1) {
ISRodd = this;
attachInterrupt(UHS_GET_DPI(irq_pin), call_ISRodd, IRQ_SENSE);
} else {
ISReven = this;
attachInterrupt(UHS_GET_DPI(irq_pin), call_ISReven, IRQ_SENSE);
}
interrupts();
#endif
//printf("\r\nrPINCTL 0x%2.2X\r\n", rPINCTL);
//printf("rCPUCTL 0x%2.2X\r\n", rCPUCTL);
//printf("rHIEN 0x%2.2X\r\n", rHIEN);
//printf("irq_pin %i\r\n", irq_pin);
return 0;
}
/**
* Setup UHS_EpInfo structure
*
* @param addr USB device address
* @param ep Endpoint
* @param ppep pointer to the pointer to a valid UHS_EpInfo structure
* @param nak_limit how many NAKs before aborting
* @return 0 on success
*/
uint8_t UHS_NI MAX3421E_HOST::SetAddress(uint8_t addr, uint8_t ep, UHS_EpInfo **ppep, uint16_t &nak_limit) {
UHS_Device *p = addrPool.GetUsbDevicePtr(addr);
if(!p)
return UHS_HOST_ERROR_NO_ADDRESS_IN_POOL;
if(!p->epinfo)
return UHS_HOST_ERROR_NULL_EPINFO;
*ppep = getEpInfoEntry(addr, ep);
if(!*ppep)
return UHS_HOST_ERROR_NO_ENDPOINT_IN_TABLE;
nak_limit = (0x0001UL << (((*ppep)->bmNakPower > UHS_USB_NAK_MAX_POWER) ? UHS_USB_NAK_MAX_POWER : (*ppep)->bmNakPower));
nak_limit--;
/*
USBTRACE2("\r\nAddress: ", addr);
USBTRACE2(" EP: ", ep);
USBTRACE2(" NAK Power: ",(*ppep)->bmNakPower);
USBTRACE2(" NAK Limit: ", nak_limit);
USBTRACE("\r\n");
*/
regWr(rPERADDR, addr); //set peripheral address
uint8_t mode = regRd(rMODE);
//Serial.print("\r\nMode: ");
//Serial.println( mode, HEX);
//Serial.print("\r\nLS: ");
//Serial.println(p->speed, HEX);
// Set bmLOWSPEED and bmHUBPRE in case of low-speed device, reset them otherwise
regWr(rMODE, (p->speed) ? mode & ~(bmHUBPRE | bmLOWSPEED) : mode | bmLOWSPEED | hub_present);
return 0;
}
/**
* Receive a packet
*
* @param pep pointer to a valid UHS_EpInfo structure
* @param nak_limit how many NAKs before aborting
* @param nbytesptr pointer to maximum number of bytes of data to receive
* @param data pointer to data buffer
* @return 0 on success
*/
uint8_t UHS_NI MAX3421E_HOST::InTransfer(UHS_EpInfo *pep, uint16_t nak_limit, uint16_t *nbytesptr, uint8_t* data) {
uint8_t rcode = 0;
uint8_t pktsize;
uint16_t nbytes = *nbytesptr;
MAX_HOST_DEBUG(PSTR("Requesting %i bytes "), nbytes);
uint8_t maxpktsize = pep->maxPktSize;
*nbytesptr = 0;
regWr(rHCTL, (pep->bmRcvToggle) ? bmRCVTOG1 : bmRCVTOG0); //set toggle value
// use a 'break' to exit this loop
while(1) {
rcode = dispatchPkt(MAX3421E_tokIN, pep->epAddr, nak_limit); //IN packet to EP-'endpoint'. Function takes care of NAKS.
#if 0
// This issue should be resolved now.
if(rcode == UHS_HOST_ERROR_TOGERR) {
//MAX_HOST_DEBUG(PSTR("toggle wrong\r\n"));
// yes, we flip it wrong here so that next time it is actually correct!
pep->bmRcvToggle = (regRd(rHRSL) & bmSNDTOGRD) ? 0 : 1;
regWr(rHCTL, (pep->bmRcvToggle) ? bmRCVTOG1 : bmRCVTOG0); //set toggle value
continue;
}
#endif
if(rcode) {
//MAX_HOST_DEBUG(PSTR(">>>>>>>> Problem! dispatchPkt %2.2x\r\n"), rcode);
break; //should be 0, indicating ACK. Else return error code.
}
/* check for RCVDAVIRQ and generate error if not present */
/* the only case when absence of RCVDAVIRQ makes sense is when toggle error occurred. Need to add handling for that */
if((regRd(rHIRQ) & bmRCVDAVIRQ) == 0) {
//MAX_HOST_DEBUG(PSTR(">>>>>>>> Problem! NO RCVDAVIRQ!\r\n"));
rcode = 0xf0; //receive error
break;
}
pktsize = regRd(rRCVBC); //number of received bytes
MAX_HOST_DEBUG(PSTR("Got %i bytes \r\n"), pktsize);
if(pktsize > nbytes) { //certain devices send more than asked
//MAX_HOST_DEBUG(PSTR(">>>>>>>> Warning: wanted %i bytes but got %i.\r\n"), nbytes, pktsize);
pktsize = nbytes;
}
int16_t mem_left = (int16_t)nbytes - *((int16_t*)nbytesptr);
if(mem_left < 0)
mem_left = 0;
data = bytesRd(rRCVFIFO, ((pktsize > mem_left) ? mem_left : pktsize), data);
regWr(rHIRQ, bmRCVDAVIRQ); // Clear the IRQ & free the buffer
*nbytesptr += pktsize; // add this packet's byte count to total transfer length
/* The transfer is complete under two conditions: */
/* 1. The device sent a short packet (L.T. maxPacketSize) */
/* 2. 'nbytes' have been transferred. */
if((pktsize < maxpktsize) || (*nbytesptr >= nbytes)) // have we transferred 'nbytes' bytes?
{
// Save toggle value
pep->bmRcvToggle = ((regRd(rHRSL) & bmRCVTOGRD)) ? 1 : 0;
//MAX_HOST_DEBUG(PSTR("\r\n"));
rcode = 0;
break;
} // if
} //while( 1 )
return ( rcode);
}
/**
* Transmit a packet
*
* @param pep pointer to a valid UHS_EpInfo structure
* @param nak_limit how many NAKs before aborting
* @param nbytes number of bytes of data to send
* @param data pointer to data buffer
* @return 0 on success
*/
uint8_t UHS_NI MAX3421E_HOST::OutTransfer(UHS_EpInfo *pep, uint16_t nak_limit, uint16_t nbytes, uint8_t *data) {
uint8_t rcode = UHS_HOST_ERROR_NONE;
uint8_t retry_count;
uint8_t *data_p = data; //local copy of the data pointer
uint16_t bytes_tosend;
uint16_t nak_count;
uint16_t bytes_left = nbytes;
uint8_t maxpktsize = pep->maxPktSize;
if(maxpktsize < 1 || maxpktsize > 64)
return UHS_HOST_ERROR_BAD_MAX_PACKET_SIZE;
unsigned long timeout = millis() + UHS_HOST_TRANSFER_MAX_MS;
regWr(rHCTL, (pep->bmSndToggle) ? bmSNDTOG1 : bmSNDTOG0); //set toggle value
while(bytes_left) {
SYSTEM_OR_SPECIAL_YIELD();
retry_count = 0;
nak_count = 0;
bytes_tosend = (bytes_left >= maxpktsize) ? maxpktsize : bytes_left;
bytesWr(rSNDFIFO, bytes_tosend, data_p); //filling output FIFO
regWr(rSNDBC, bytes_tosend); //set number of bytes
regWr(rHXFR, (MAX3421E_tokOUT | pep->epAddr)); //dispatch packet
while(!(regRd(rHIRQ) & bmHXFRDNIRQ)); //wait for the completion IRQ
regWr(rHIRQ, bmHXFRDNIRQ); //clear IRQ
rcode = (regRd(rHRSL) & 0x0f);
while(rcode && ((long)(millis() - timeout) < 0L)) {
switch(rcode) {
case UHS_HOST_ERROR_NAK:
nak_count++;
if(nak_limit && (nak_count == nak_limit))
goto breakout;
break;
case UHS_HOST_ERROR_TIMEOUT:
retry_count++;
if(retry_count == UHS_HOST_TRANSFER_RETRY_MAXIMUM)
goto breakout;
break;
case UHS_HOST_ERROR_TOGERR:
// yes, we flip it wrong here so that next time it is actually correct!
pep->bmSndToggle = (regRd(rHRSL) & bmSNDTOGRD) ? 0 : 1;
regWr(rHCTL, (pep->bmSndToggle) ? bmSNDTOG1 : bmSNDTOG0); //set toggle value
break;
default:
goto breakout;
}//switch( rcode
/* process NAK according to Host out NAK bug */
regWr(rSNDBC, 0);
regWr(rSNDFIFO, *data_p);
regWr(rSNDBC, bytes_tosend);
regWr(rHXFR, (MAX3421E_tokOUT | pep->epAddr)); //dispatch packet
while(!(regRd(rHIRQ) & bmHXFRDNIRQ)); //wait for the completion IRQ
regWr(rHIRQ, bmHXFRDNIRQ); //clear IRQ
rcode = (regRd(rHRSL) & 0x0f);
SYSTEM_OR_SPECIAL_YIELD();
}//while( rcode && ....
bytes_left -= bytes_tosend;
data_p += bytes_tosend;
}//while( bytes_left...
breakout:
pep->bmSndToggle = (regRd(rHRSL) & bmSNDTOGRD) ? 1 : 0; //bmSNDTOG1 : bmSNDTOG0; //update toggle
return ( rcode); //should be 0 in all cases
}
/**
* Send the actual packet.
*
* @param token
* @param ep Endpoint
* @param nak_limit how many NAKs before aborting, 0 == exit after timeout
* @return 0 on success, 0xFF indicates NAK timeout. @see
*/
/* Assumes peripheral address is set and relevant buffer is loaded/empty */
/* If NAK, tries to re-send up to nak_limit times */
/* If nak_limit == 0, do not count NAKs, exit after timeout */
/* If bus timeout, re-sends up to USB_RETRY_LIMIT times */
/* return codes 0x00-0x0f are HRSLT( 0x00 being success ), 0xff means timeout */
uint8_t UHS_NI MAX3421E_HOST::dispatchPkt(uint8_t token, uint8_t ep, uint16_t nak_limit) {
unsigned long timeout = millis() + UHS_HOST_TRANSFER_MAX_MS;
uint8_t tmpdata;
uint8_t rcode = UHS_HOST_ERROR_NONE;
uint8_t retry_count = 0;
uint16_t nak_count = 0;
for(;;) {
regWr(rHXFR, (token | ep)); //launch the transfer
while((long)(millis() - timeout) < 0L) //wait for transfer completion
{
SYSTEM_OR_SPECIAL_YIELD();
tmpdata = regRd(rHIRQ);
if(tmpdata & bmHXFRDNIRQ) {
regWr(rHIRQ, bmHXFRDNIRQ); //clear the interrupt
//rcode = 0x00;
break;
}//if( tmpdata & bmHXFRDNIRQ
}//while ( millis() < timeout
rcode = (regRd(rHRSL) & 0x0f); //analyze transfer result
switch(rcode) {
case UHS_HOST_ERROR_NAK:
nak_count++;
if(nak_limit && (nak_count == nak_limit))
return (rcode);
delayMicroseconds(200);
break;
case UHS_HOST_ERROR_TIMEOUT:
retry_count++;
if(retry_count == UHS_HOST_TRANSFER_RETRY_MAXIMUM)
return (rcode);
break;
default:
return (rcode);
}//switch( rcode
}
}
//
// NULL is error, we don't need to know the reason.
//
UHS_EpInfo * UHS_NI MAX3421E_HOST::ctrlReqOpen(uint8_t addr, uint64_t Request, uint8_t *dataptr) {
uint8_t rcode;
UHS_EpInfo *pep = NULL;
uint16_t nak_limit = 0;
rcode = SetAddress(addr, 0, &pep, nak_limit);
if(!rcode) {
bytesWr(rSUDFIFO, 8, (uint8_t*)(&Request)); //transfer to setup packet FIFO
rcode = dispatchPkt(MAX3421E_tokSETUP, 0, nak_limit); //dispatch packet
if(!rcode) {
if(dataptr != NULL) {
if(((Request)/* bmReqType*/ & 0x80) == 0x80) {
pep->bmRcvToggle = 1; //bmRCVTOG1;
} else {
pep->bmSndToggle = 1; //bmSNDTOG1;
}
}
} else {
pep = NULL;
}
}
return pep;
}
uint8_t UHS_NI MAX3421E_HOST::ctrlReqRead(UHS_EpInfo *pep, uint16_t *left, uint16_t *read, uint16_t nbytes, uint8_t *dataptr) {
*read = 0;
uint16_t nak_limit = 0;
MAX_HOST_DEBUG(PSTR("ctrlReqRead left: %i\r\n"), *left);
if(*left) {
again:
*read = nbytes;
uint8_t rcode = InTransfer(pep, nak_limit, read, dataptr);
if(rcode == UHS_HOST_ERROR_TOGERR) {
// yes, we flip it wrong here so that next time it is actually correct!
pep->bmRcvToggle = (regRd(rHRSL) & bmSNDTOGRD) ? 0 : 1;
goto again;
}
if(rcode) {
MAX_HOST_DEBUG(PSTR("ctrlReqRead ERROR: %2.2x, left: %i, read %i\r\n"), rcode, *left, *read);
return rcode;
}
*left -= *read;
MAX_HOST_DEBUG(PSTR("ctrlReqRead left: %i, read %i\r\n"), *left, *read);
}
return 0;
}
uint8_t UHS_NI MAX3421E_HOST::ctrlReqClose(UHS_EpInfo *pep, uint8_t bmReqType, uint16_t left, uint16_t nbytes, uint8_t *dataptr) {
uint8_t rcode = 0;
//MAX_HOST_DEBUG(PSTR("Closing"));
if(((bmReqType & 0x80) == 0x80) && pep && left && dataptr) {
MAX_HOST_DEBUG(PSTR("ctrlReqRead Sinking %i\r\n"), left);
// If reading, sink the rest of the data.
while(left) {
uint16_t read = nbytes;
rcode = InTransfer(pep, 0, &read, dataptr);
if(rcode == UHS_HOST_ERROR_TOGERR) {
// yes, we flip it wrong here so that next time it is actually correct!
pep->bmRcvToggle = (regRd(rHRSL) & bmSNDTOGRD) ? 0 : 1;
continue;
}
if(rcode) break;
left -= read;
if(read < nbytes) break;
}
}
if(!rcode) {
// Serial.println("Dispatching");
rcode = dispatchPkt(((bmReqType & 0x80) == 0x80) ? MAX3421E_tokOUTHS : MAX3421E_tokINHS, 0, 0); //GET if direction
// } else {
// Serial.println("Bypassed Dispatch");
}
return rcode;
}
/**
* Bottom half of the ISR task
*/
void UHS_NI MAX3421E_HOST::ISRbottom(void) {
uint8_t x;
// Serial.print("Enter ");
// Serial.print((uint32_t)this,HEX);
// Serial.print(" ");
// Serial.println(usb_task_state, HEX);
DDSB();
if(condet) {
VBUS_changed();
#if USB_HOST_SHIELD_USE_ISR
noInterrupts();
#endif
condet = false;
#if USB_HOST_SHIELD_USE_ISR
interrupts();
#endif
}
switch(usb_task_state) {
case UHS_USB_HOST_STATE_INITIALIZE:
// should never happen...
MAX_HOST_DEBUG(PSTR("UHS_USB_HOST_STATE_INITIALIZE\r\n"));
busprobe();
VBUS_changed();
break;
case UHS_USB_HOST_STATE_DEBOUNCE:
MAX_HOST_DEBUG(PSTR("UHS_USB_HOST_STATE_DEBOUNCE\r\n"));
// This seems to not be needed. The host controller has debounce built in.
sof_countdown = UHS_HOST_DEBOUNCE_DELAY_MS;
usb_task_state = UHS_USB_HOST_STATE_DEBOUNCE_NOT_COMPLETE;
break;
case UHS_USB_HOST_STATE_DEBOUNCE_NOT_COMPLETE:
MAX_HOST_DEBUG(PSTR("UHS_USB_HOST_STATE_DEBOUNCE_NOT_COMPLETE\r\n"));
if(!sof_countdown) usb_task_state = UHS_USB_HOST_STATE_RESET_DEVICE;
break;
case UHS_USB_HOST_STATE_RESET_DEVICE:
MAX_HOST_DEBUG(PSTR("UHS_USB_HOST_STATE_RESET_DEVICE\r\n"));
busevent = true;
usb_task_state = UHS_USB_HOST_STATE_RESET_NOT_COMPLETE;
regWr(rHIRQ, bmBUSEVENTIRQ); // see data sheet.
regWr(rHCTL, bmBUSRST); // issue bus reset
break;
case UHS_USB_HOST_STATE_RESET_NOT_COMPLETE:
MAX_HOST_DEBUG(PSTR("UHS_USB_HOST_STATE_RESET_NOT_COMPLETE\r\n"));
if(!busevent) usb_task_state = UHS_USB_HOST_STATE_WAIT_BUS_READY;
break;
case UHS_USB_HOST_STATE_WAIT_BUS_READY:
MAX_HOST_DEBUG(PSTR("UHS_USB_HOST_STATE_WAIT_BUS_READY\r\n"));
usb_task_state = UHS_USB_HOST_STATE_CONFIGURING;
break; // don't fall through
case UHS_USB_HOST_STATE_CONFIGURING:
usb_task_state = UHS_USB_HOST_STATE_CHECK;
x = Configuring(0, 1, usb_host_speed);
usb_error = x;
if(usb_task_state == UHS_USB_HOST_STATE_CHECK) {
if(x) {
MAX_HOST_DEBUG(PSTR("Error 0x%2.2x"), x);
if(x == UHS_HOST_ERROR_JERR) {
usb_task_state = UHS_USB_HOST_STATE_IDLE;
} else if(x != UHS_HOST_ERROR_DEVICE_INIT_INCOMPLETE) {
usb_error = x;
usb_task_state = UHS_USB_HOST_STATE_ERROR;
}
} else
usb_task_state = UHS_USB_HOST_STATE_CONFIGURING_DONE;
}
break;
case UHS_USB_HOST_STATE_CHECK:
// Serial.println((uint32_t)__builtin_return_address(0), HEX);
break;
case UHS_USB_HOST_STATE_CONFIGURING_DONE:
usb_task_state = UHS_USB_HOST_STATE_RUNNING;
break;
#ifdef USB_HOST_MANUAL_POLL
case UHS_USB_HOST_STATE_RUNNING:
case UHS_USB_HOST_STATE_ERROR:
case UHS_USB_HOST_STATE_IDLE:
case UHS_USB_HOST_STATE_ILLEGAL:
enable_frame_irq(false);
break;
#else
case UHS_USB_HOST_STATE_RUNNING:
Poll_Others();
for(x = 0; (usb_task_state == UHS_USB_HOST_STATE_RUNNING) && (x < UHS_HOST_MAX_INTERFACE_DRIVERS); x++) {
if(devConfig[x]) {
if(devConfig[x]->bPollEnable) devConfig[x]->Poll();
}
}
// fall thru
#endif
default:
// Do nothing
break;
} // switch( usb_task_state )
DDSB();
#if USB_HOST_SHIELD_USE_ISR
if(condet) {
VBUS_changed();
noInterrupts();
condet = false;
interrupts();
}
#endif
#ifdef USB_HOST_SHIELD_TIMING_PIN
// My counter/timer can't work on an inverted gate signal
// so we gate using a high pulse -- AJK
UHS_PIN_WRITE(USB_HOST_SHIELD_TIMING_PIN, LOW);
#endif
//usb_task_polling_disabled--;
EnablePoll();
DDSB();
}
/* USB main task. Services the MAX3421e */
#if !USB_HOST_SHIELD_USE_ISR
void UHS_NI MAX3421E_HOST::ISRTask(void) {
}
void UHS_NI MAX3421E_HOST::Task(void)
#else
void UHS_NI MAX3421E_HOST::Task(void) {
#ifdef USB_HOST_MANUAL_POLL
if(usb_task_state == UHS_USB_HOST_STATE_RUNNING) {
noInterrupts();
for(uint8_t x = 0; x < UHS_HOST_MAX_INTERFACE_DRIVERS; x++)
if(devConfig[x] && devConfig[x]->bPollEnable)
devConfig[x]->Poll();
interrupts();
}
#endif
}
void UHS_NI MAX3421E_HOST::ISRTask(void)
#endif
{
DDSB();
#if !defined(SWI_IRQ_NUM)
suspend_host();
#if USB_HOST_SHIELD_USE_ISR
// Enable interrupts
interrupts();
#endif
#endif
counted = false;
if(!MARLIN_UHS_READ_IRQ()) {
uint8_t HIRQALL = regRd(rHIRQ); //determine interrupt source
uint8_t HIRQ = HIRQALL & IRQ_CHECK_MASK;
uint8_t HIRQ_sendback = 0x00;
if((HIRQ & bmCONDETIRQ) || (HIRQ & bmBUSEVENTIRQ)) {
MAX_HOST_DEBUG
(PSTR("\r\nBEFORE CDIRQ %s BEIRQ %s resetting %s state 0x%2.2x\r\n"),
(HIRQ & bmCONDETIRQ) ? "T" : "F",
(HIRQ & bmBUSEVENTIRQ) ? "T" : "F",
doingreset ? "T" : "F",
usb_task_state
);
}
// ALWAYS happens BEFORE or WITH CONDETIRQ
if(HIRQ & bmBUSEVENTIRQ) {
HIRQ_sendback |= bmBUSEVENTIRQ;
if(!doingreset) condet = true;
busprobe();
busevent = false;
}
if(HIRQ & bmCONDETIRQ) {
HIRQ_sendback |= bmCONDETIRQ;
if(!doingreset) condet = true;
busprobe();
}
#if 1
if((HIRQ & bmCONDETIRQ) || (HIRQ & bmBUSEVENTIRQ)) {
MAX_HOST_DEBUG
(PSTR("\r\nAFTER CDIRQ %s BEIRQ %s resetting %s state 0x%2.2x\r\n"),
(HIRQ & bmCONDETIRQ) ? "T" : "F",
(HIRQ & bmBUSEVENTIRQ) ? "T" : "F",
doingreset ? "T" : "F",
usb_task_state
);
}
#endif
if(HIRQ & bmFRAMEIRQ) {
HIRQ_sendback |= bmFRAMEIRQ;
if(sof_countdown) {
sof_countdown--;
counted = true;
}
sofevent = false;
}
//MAX_HOST_DEBUG(PSTR("\r\n%s%s%s\r\n"),
// sof_countdown ? "T" : "F",
// counted ? "T" : "F",
// usb_task_polling_disabled? "T" : "F");
DDSB();
regWr(rHIRQ, HIRQ_sendback);
#if !defined(SWI_IRQ_NUM)
resume_host();
#if USB_HOST_SHIELD_USE_ISR
// Disable interrupts
noInterrupts();
#endif
#endif
if(!sof_countdown && !counted && !usb_task_polling_disabled) {
DisablePoll();
//usb_task_polling_disabled++;
#ifdef USB_HOST_SHIELD_TIMING_PIN
// My counter/timer can't work on an inverted gate signal
// so we gate using a high pulse -- AJK
UHS_PIN_WRITE(USB_HOST_SHIELD_TIMING_PIN, HIGH);
#endif
#if defined(SWI_IRQ_NUM)
// MAX_HOST_DEBUG(PSTR("--------------- Doing SWI ----------------"));
exec_SWI(this);
#else
#if USB_HOST_SHIELD_USE_ISR
// Enable interrupts
interrupts();
#endif /* USB_HOST_SHIELD_USE_ISR */
ISRbottom();
#endif /* SWI_IRQ_NUM */
}
}
}
#if 0
DDSB();
#endif
#else
#error "Never include USB_HOST_SHIELD_INLINE.h, include UHS_host.h instead"
#endif

153
Marlin/src/sd/usb_flashdrive/lib-uhs3/UHS_host/macro_logic.h Normal file
View file

@ -0,0 +1,153 @@
/*
* File: macro_logic.h
* Author: root
*
* Created on December 22, 2018, 4:49 AM
*
* To test:
* gcc -DAJK_TEST_MACRO_LOGIC -E macro_logic.h
*
*/
#ifndef MACRO_LOGIC_H
#define MACRO_LOGIC_H
#define AJK_CAT(a, ...) AJK_PRIMITIVE_CAT(a, __VA_ARGS__)
#define AJK_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__
#define AJK_COMPL(b) AJK_PRIMITIVE_CAT(AJK_COMPL_, b)
#define AJK_COMPL_0 1
#define AJK_COMPL_1 0
#define AJK_BITAND(x) AJK_PRIMITIVE_CAT(AJK_BITAND_, x)
#define AJK_BITAND_0(y) 0
#define AJK_BITAND_1(y) y
#define AJK_INC(x) AJK_PRIMITIVE_CAT(AJK_INC_, x)
#define AJK_INC_0 1
#define AJK_INC_1 2
#define AJK_INC_2 3
#define AJK_INC_3 4
#define AJK_INC_4 5
#define AJK_INC_5 6
#define AJK_INC_6 7
#define AJK_INC_7 8
#define AJK_INC_8 9
#define AJK_INC_9 10
#define AJK_INC_10 10
#define AJK_DEC(x) AJK_PRIMITIVE_CAT(AJK_DEC_, x)
#define AJK_DEC_0 0
#define AJK_DEC_1 0
#define AJK_DEC_2 1
#define AJK_DEC_3 2
#define AJK_DEC_4 3
#define AJK_DEC_5 4
#define AJK_DEC_6 5
#define AJK_DEC_7 6
#define AJK_DEC_8 7
#define AJK_DEC_9 8
#define AJK_DEC_10 9
#define AJK_CHECK_N(x, n, ...) n
#define AJK_CHECK(...) AJK_CHECK_N(__VA_ARGS__, 0,)
#define AJK_PROBE(x) x, 1,
#define AJK_IS_PAREN(x) AJK_CHECK(AJK_IS_PAREN_PROBE x)
#define AJK_IS_PAREN_PROBE(...) AJK_PROBE(~)
#define AJK_NOT(x) AJK_CHECK(AJK_PRIMITIVE_CAT(AJK_NOT_, x))
#define AJK_NOT_0 AJK_PROBE(~)
#define AJK_COMPL(b) AJK_PRIMITIVE_CAT(AJK_COMPL_, b)
#define AJK_COMPL_0 1
#define AJK_COMPL_1 0
#define AJK_BOOL(x) AJK_COMPL(AJK_NOT(x))
#define AJK_IIF(c) AJK_PRIMITIVE_CAT(AJK_IIF_, c)
#define AJK_IIF_0(t, ...) __VA_ARGS__
#define AJK_IIF_1(t, ...) t
#define AJK_IF(c) AJK_IIF(AJK_BOOL(c))
#define AJK_EAT(...)
#define AJK_EXPAND(...) __VA_ARGS__
#define AJK_WHEN(c) AJK_IF(c)(AJK_EXPAND, AJK_EAT)
#define AJK_EMPTY()
#define AJK_DEFER(id) id AJK_EMPTY()
#define AJK_OBSTRUCT(id) id AJK_DEFER(AJK_EMPTY)()
#define AJK_EVAL(...) AJK_EVAL1(AJK_EVAL1(AJK_EVAL1(__VA_ARGS__)))
#define AJK_EVAL1(...) AJK_EVAL2(AJK_EVAL2(AJK_EVAL2(__VA_ARGS__)))
#define AJK_EVAL2(...) AJK_EVAL3(AJK_EVAL3(AJK_EVAL3(__VA_ARGS__)))
#define AJK_EVAL3(...) AJK_EVAL4(AJK_EVAL4(AJK_EVAL4(__VA_ARGS__)))
#define AJK_EVAL4(...) AJK_EVAL5(AJK_EVAL5(AJK_EVAL5(__VA_ARGS__)))
#define AJK_EVAL5(...) __VA_ARGS__
#define AJK_REPEAT(AJK_count, AJK_macro, ...) \
AJK_WHEN(AJK_count) \
( \
AJK_OBSTRUCT(AJK_REPEAT_INDIRECT) () \
( \
AJK_DEC(AJK_count), AJK_macro, __VA_ARGS__ \
) \
AJK_OBSTRUCT(AJK_macro) \
( \
AJK_DEC(AJK_count), __VA_ARGS__ \
) \
)
#define AJK_REPEAT_INDIRECT() AJK_REPEAT
#define AJK_WHILE(AJK_pred, AJK_op, ...) \
IF(AJK_pred(__VA_ARGS__)) \
( \
AJK_OBSTRUCT(AJK_WHILE_INDIRECT) () \
( \
AJK_pred, AJK_op, AJK_op(__VA_ARGS__) \
), \
__VA_ARGS__ \
)
#define AJK_WHILE_INDIRECT() AJK_WHILE
#define AJK_PRIMITIVE_COMPARE(x, y) AJK_IS_PAREN \
( \
AJK_COMPARE_ ## x ( AJK_COMPARE_ ## y) (()) \
)
#define AJK_IS_COMPARABLE(x) AJK_IS_PAREN( AJK_CAT(AJK_COMPARE_, x) (()) )
#define AJK_NOT_EQUAL(x, y) \
AJK_IIF(AJK_BITAND(AJK_IS_COMPARABLE(x))(AJK_IS_COMPARABLE(y)) ) \
( \
AJK_PRIMITIVE_COMPARE, \
1 AJK_EAT \
)(x, y)
#define AJK_EQUAL(x, y) AJK_COMPL(AJK_NOT_EQUAL(x, y))
#define AJK_COMMA() ,
#define AJK_COMMA_IF(n) AJK_IF(n)(AJK_COMMA, AJK_EAT)()
#define AJK_COMMA_VAR(AJK_count, AJK_v) AJK_COMMA_IF(AJK_count) AJK_v ## AJK_count
#define AJK_MAKE_LIST(AJK_v, AJK_count) AJK_EVAL(AJK_REPEAT(AJK_count, AJK_COMMA_VAR, AJK_v))
#define AJK_FUN(AJK_count, AJK_v, AJK_args, AJK_body) AJK_v ## AJK_count (AJK_args) { AJK_body(AJK_count) }
#define AJK_MAKE_FUNS(AJK_v, AJK_args, AJK_count, AJK_body) AJK_EVAL(AJK_REPEAT(AJK_count, AJK_FUN, AJK_v, AJK_args, AJK_body))
#if defined(AJK_TEST_MACRO_LOGIC)
#define BODY(AJKindex) some(C, statement); contaning(a, test[AJKindex]);
#define ZERO_TIMES_TEST 0
#define THREE_TIMES_TEST 3
blank > AJK_MAKE_LIST(VARIABLE_, ZERO_TIMES_TEST) < because zero repeats
Make 3 comma separated indexed variables : AJK_MAKE_LIST(VARIABLE_, THREE_TIMES_TEST)
Make 3 bogus function bodies
AJK_MAKE_FUNS(unsigned Cfunc,(arg1, arg2),3,BODY)
#endif
#endif /* MACRO_LOGIC_H */

246
Marlin/src/sd/usb_flashdrive/lib-uhs3/dyn_SWI/SWI_INLINE.h Normal file
View file

@ -0,0 +1,246 @@
/*
* File: SWI_INLINE.h
* Author: xxxajk@gmail.com
*
* Created on December 5, 2014, 9:40 AM
*
* This is the actual library.
* There are no 'c' or 'cpp' files.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef DYN_SWI_H
#ifndef SWI_INLINE_H
#define SWI_INLINE_H
#ifndef SWI_MAXIMUM_ALLOWED
#define SWI_MAXIMUM_ALLOWED 4
#endif
#if defined(__arm__) || defined(ARDUINO_ARCH_PIC32)
static char dyn_SWI_initied = 0;
static dyn_SWI* dyn_SWI_LIST[SWI_MAXIMUM_ALLOWED];
static dyn_SWI* dyn_SWI_EXEC[SWI_MAXIMUM_ALLOWED];
#if defined(__arm__)
#if defined(__USE_CMSIS_VECTORS__)
extern "C" {
void (*_VectorsRam[VECTORTABLE_SIZE])(void)__attribute__((aligned(VECTORTABLE_ALIGNMENT)));
}
#else
__attribute__((always_inline)) static inline void __DSB(void) {
__asm__ volatile ("dsb");
}
#endif // defined(__USE_CMSIS_VECTORS__)
#else // defined(__arm__)
__attribute__((always_inline)) static inline void __DSB(void) {
__asm__ volatile ("sync" : : : "memory");
}
#endif // defined(__arm__)
/**
* Execute queued class ISR routines.
*/
#if defined(ARDUINO_ARCH_PIC32)
static p32_regset *ifs = ((p32_regset *) & IFS0) + (SWI_IRQ_NUM / 32); //interrupt flag register set
static p32_regset *iec = ((p32_regset *) & IEC0) + (SWI_IRQ_NUM / 32); //interrupt enable control reg set
static uint32_t swibit = 1 << (SWI_IRQ_NUM % 32);
void
#if defined(__PIC32MZXX__)
__attribute__((nomips16,at_vector(SWI_VECTOR),interrupt(SWI_IPL)))
#else
__attribute__((interrupt(),nomips16))
#endif
softISR(void) {
#else
#if defined(ARDUINO_spresense_ast)
unsigned int softISR(void) {
#else
void softISR(void) {
#endif
#endif
//
// TO-DO: Perhaps limit to 8, and inline this?
//
// Make a working copy, while clearing the queue.
noInterrupts();
#if defined(ARDUINO_ARCH_PIC32)
//ifs->clr = swibit;
#endif
for(int i = 0; i < SWI_MAXIMUM_ALLOWED; i++) {
dyn_SWI_EXEC[i] = dyn_SWI_LIST[i];
dyn_SWI_LIST[i] = NULL;
}
__DSB();
interrupts();
// Execute each class SWI
for(int i = 0; i < SWI_MAXIMUM_ALLOWED; i++) {
if(dyn_SWI_EXEC[i]) {
#if defined(__DYN_SWI_DEBUG_LED__)
digitalWrite(__DYN_SWI_DEBUG_LED__, HIGH);
#endif
dyn_SWI_EXEC[i]->dyn_SWISR();
#if defined(__DYN_SWI_DEBUG_LED__)
digitalWrite(__DYN_SWI_DEBUG_LED__, LOW);
#endif
}
}
#if defined(ARDUINO_ARCH_PIC32)
noInterrupts();
if(!dyn_SWI_EXEC[0]) ifs->clr = swibit;
interrupts();
#endif
#if defined(ARDUINO_spresense_ast)
return 0;
#endif
}
#define DDSB() __DSB()
#endif
#if defined(__arm__)
#ifndef interruptsStatus
#define interruptsStatus() __interruptsStatus()
static inline unsigned char __interruptsStatus(void) __attribute__((always_inline, unused));
static inline unsigned char __interruptsStatus(void) {
unsigned int primask;
asm volatile ("mrs %0, primask" : "=r" (primask));
if(primask) return 0;
return 1;
}
#endif
/**
* Initialize the Dynamic (class) Software Interrupt
*/
static void Init_dyn_SWI(void) {
if(!dyn_SWI_initied) {
#if defined(__USE_CMSIS_VECTORS__)
uint32_t *X_Vectors = (uint32_t*)SCB->VTOR;
for(int i = 0; i < VECTORTABLE_SIZE; i++) {
_VectorsRam[i] = reinterpret_cast<void (*)()>(X_Vectors[i]); /* copy vector table to RAM */
}
/* relocate vector table */
noInterrupts();
SCB->VTOR = reinterpret_cast<uint32_t>(&_VectorsRam);
DDSB();
interrupts();
#endif
#if !defined(ARDUINO_spresense_ast)
for(int i = 0; i < SWI_MAXIMUM_ALLOWED; i++) dyn_SWI_LIST[i] = NULL;
noInterrupts();
_VectorsRam[SWI_IRQ_NUM + 16] = reinterpret_cast<void (*)()>(softISR);
DDSB();
interrupts();
NVIC_SET_PRIORITY(SWI_IRQ_NUM, 255);
NVIC_ENABLE_IRQ(SWI_IRQ_NUM);
#endif
#if defined(__DYN_SWI_DEBUG_LED__)
pinMode(__DYN_SWI_DEBUG_LED__, OUTPUT);
digitalWrite(__DYN_SWI_DEBUG_LED__, LOW);
#endif
dyn_SWI_initied = 1;
}
}
/**
*
* @param klass class that extends dyn_SWI
* @return 0 on queue full, else returns queue position (ones based)
*/
int exec_SWI(const dyn_SWI* klass) {
int rc = 0;
uint8_t irestore = interruptsStatus();
// Allow use from inside a critical section...
// ... and prevent races if also used inside an ISR
noInterrupts();
for(int i = 0; i < SWI_MAXIMUM_ALLOWED; i++) {
if(!dyn_SWI_LIST[i]) {
rc = 1 + i; // Success!
dyn_SWI_LIST[i] = (dyn_SWI*)klass;
#if !defined(ARDUINO_spresense_ast)
if(!NVIC_GET_PENDING(SWI_IRQ_NUM)) NVIC_SET_PENDING(SWI_IRQ_NUM);
#else
// Launch 1-shot timer as an emulated SWI
// Hopefully the value of Zero is legal.
// 1 microsecond latency would suck!
attachTimerInterrupt(softISR, 100);
#endif
DDSB();
break;
}
}
// Restore interrupts, if they were on.
if(irestore) interrupts();
return rc;
}
#elif defined(ARDUINO_ARCH_PIC32)
/**
* Initialize the Dynamic (class) Software Interrupt
*/
static void Init_dyn_SWI(void) {
if(!dyn_SWI_initied) {
uint32_t sreg = disableInterrupts();
setIntVector(SWI_VECTOR, softISR);
setIntPriority(SWI_VECTOR, 1, 1); // Lowest priority, ever.
ifs->clr = swibit;
iec->clr = swibit;
iec->set = swibit;
restoreInterrupts(sreg);
#if defined(__DYN_SWI_DEBUG_LED__)
pinMode(__DYN_SWI_DEBUG_LED__, OUTPUT);
UHS_PIN_WRITE(__DYN_SWI_DEBUG_LED__, LOW);
#endif
}
}
/**
*
* @param klass class that extends dyn_SWI
* @return 0 on queue full, else returns queue position (ones based)
*/
int exec_SWI(const dyn_SWI* klass) {
int rc = 0;
uint32_t sreg = disableInterrupts();
for(int i = 0; i < SWI_MAXIMUM_ALLOWED; i++) {
if(!dyn_SWI_LIST[i]) {
rc = 1 + i; // Success!
dyn_SWI_LIST[i] = (dyn_SWI*)klass;
if(!(ifs->reg & swibit)) ifs->set = swibit;
;
break;
}
}
restoreInterrupts(sreg);
return rc;
}
#endif /* defined(__arm__) */
#endif /* SWI_INLINE_H */
#else
#error "Never include SWI_INLINE.h directly, include dyn_SWI.h instead"
#endif

172
Marlin/src/sd/usb_flashdrive/lib-uhs3/dyn_SWI/dyn_SWI.h Normal file
View file

@ -0,0 +1,172 @@
/*
* File: dyn_SWI.h
* Author: xxxajk@gmail.com
*
* Created on December 5, 2014, 9:12 AM
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef DYN_SWI_H
#define DYN_SWI_H
#if defined(__arm__) || defined(ARDUINO_ARCH_PIC32)
#if defined(ARDUINO_ARCH_PIC32)
#include <p32xxxx.h>
#endif
#ifdef __cplusplus
#if defined(true)
#undef true
#endif
#if defined(false)
#undef false
#endif
#endif
#if defined(ARDUINO_spresense_ast)
#define SWI_IRQ_NUM 666 // because this board is totally evil.
#elif defined(ARDUINO_ARCH_PIC32)
#ifndef SWI_IRQ_NUM
#if defined(_DSPI0_IPL_ISR)
#define SWI_IPL _DSPI0_IPL_ISR
#define SWI_VECTOR _DSPI0_ERR_IRQ
#define SWI_IRQ_NUM _DSPI0_ERR_IRQ
#elif defined(_PMP_ERROR_IRQ)
#define SWI_IRQ_NUM _PMP_ERROR_IRQ
#define SWI_VECTOR _PMP_VECTOR
#else
#error SWI_IRQ_NUM and SWI_VECTOR need a definition
#endif
#ifdef __cplusplus
extern "C"
{
void
#if defined(__PIC32MZXX__)
__attribute__((nomips16,at_vector(SWI_VECTOR),interrupt(SWI_IPL)))
#else
__attribute__((interrupt(),nomips16))
#endif
softISR(void);
}
#endif
#endif
#elif !defined(NVIC_NUM_INTERRUPTS)
// Assume CMSIS
#define __USE_CMSIS_VECTORS__
#if defined(NUMBER_OF_INT_VECTORS)
#define NVIC_NUM_INTERRUPTS (NUMBER_OF_INT_VECTORS-16)
#else
#define NVIC_NUM_INTERRUPTS ((int)PERIPH_COUNT_IRQn)
#endif
#define VECTORTABLE_SIZE (NVIC_NUM_INTERRUPTS+16)
#define VECTORTABLE_ALIGNMENT (0x100ul)
#define NVIC_GET_ACTIVE(n) NVIC_GetActive((IRQn_Type)n)
#define NVIC_GET_PENDING(n) NVIC_GetPendingIRQ((IRQn_Type)n)
#define NVIC_SET_PENDING(n) NVIC_SetPendingIRQ((IRQn_Type)n)
#define NVIC_ENABLE_IRQ(n) NVIC_EnableIRQ((IRQn_Type)n)
#define NVIC_SET_PRIORITY(n ,p) NVIC_SetPriority((IRQn_Type)n, (uint32_t) p)
//extern "C" {
// extern uint32_t _VectorsRam[VECTORTABLE_SIZE] __attribute__((aligned(VECTORTABLE_ALIGNMENT)));
//}
#ifndef SWI_IRQ_NUM
#if defined(__SAM3X8E__) && defined(_VARIANT_ARDUINO_DUE_X_)
// DUE
// Choices available:
// HSMCI_IRQn Multimedia Card Interface (HSMCI)
// EMAC_IRQn Ethernet MAC (EMAC)
// EMAC is not broken out on the official DUE, but is on clones.
// SPI0_IRQn Serial Peripheral Interface (SPI0)
// SPI0_IRQn seems to be the best choice, as long as nobody uses an ISR based master
#define SWI_IRQ_NUM SPI0_IRQn
#elif defined(ARDUINO_SAMD_ZERO)
// Just use sercom4's unused IRQ vector.
#define SWI_IRQ_NUM I2S_IRQn
//#define SWI_IRQ_NUM SERCOM4_IRQn
#endif
#endif
#ifndef SWI_IRQ_NUM
#error SWI_IRQ_NUM not defined (CMSIS)
#endif
#elif defined(CORE_TEENSY)
#ifndef NVIC_GET_ACTIVE
#define NVIC_GET_ACTIVE(n) (*((volatile uint32_t *)0xE000E300 + ((n) >> 5)) & (1 << ((n) & 31)))
#endif
#ifndef NVIC_GET_PENDING
#define NVIC_GET_PENDING(n) (*((volatile uint32_t *)0xE000E200 + ((n) >> 5)) & (1 << ((n) & 31)))
#ifndef SWI_IRQ_NUM
#if defined(__MK20DX256__)
#define SWI_IRQ_NUM 17
#elif defined(__MK20DX128__)
#define SWI_IRQ_NUM 5
#elif defined(__MKL26Z64__)
#define SWI_IRQ_NUM 4
#elif defined(__MK66FX1M0__)
#define SWI_IRQ_NUM 30
#elif defined(__MK64FX512__)
#define SWI_IRQ_NUM 30
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
#define SWI_IRQ_NUM 71
#else
#error Do not know how to relocate IRQ vectors for this pjrc product
#endif
#endif
#endif
#else // Not CMSIS or PJRC CORE_TEENSY or PIC32 or SPRESENSE
#error Do not know how to relocate IRQ vectors or perform SWI
#endif // SWI_IRQ_NUM
#ifndef SWI_IRQ_NUM
#error SWI_IRQ_NUM not defined
#else
/**
* Use this class to extend your class, in order to provide
* a C++ context callable SWI.
*/
class dyn_SWI {
public:
/**
* Override this method with your code.
*/
virtual void dyn_SWISR(void) {
};
};
extern int exec_SWI(const dyn_SWI* klass);
#include "SWI_INLINE.h"
// IMPORTANT! Define this so that you do NOT end up with a NULL stub!
#define SWI_NO_STUB
#endif /* SWI_IRQ_NUM */
#endif /* __arm__ */
// if no SWI for CPU (e.g. AVR) make a void stub.
#ifndef SWI_NO_STUB
#define Init_dyn_SWI() (void(0))
#if !defined(DDSB)
#define DDSB() (void(0))
#endif
#endif
#endif /* DYN_SWI_H */

187
Marlin/src/sd/usb_flashdrive/usb-2.0-host-library-changes.patch
View file

@ -1,187 +0,0 @@
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/masstorage.cpp lib/masstorage.cpp
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/masstorage.cpp 2018-09-21 10:19:36.107502252 -0600
+++ lib/masstorage.cpp 2018-09-21 09:46:19.620175519 -0600
@@ -24,6 +24,8 @@
#include "masstorage.h"
+#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
+
const uint8_t BulkOnly::epDataInIndex = 1;
const uint8_t BulkOnly::epDataOutIndex = 2;
const uint8_t BulkOnly::epInterruptInIndex = 3;
@@ -796,6 +798,9 @@
buf[i] = 0x00;
}
WriteOk[lun] = true;
+ #if ENABLED(USB_FLASH_DRIVE_SUPPORT) && defined(SKIP_WRITE_PROTECT)
+ return 0;
+ #endif
uint8_t rc = ModeSense6(lun, 0, 0x3f, 0, 192, buf);
if(!rc) {
WriteOk[lun] = ((buf[2] & 0x80) == 0);
@@ -1271,3 +1276,5 @@
return MASS_ERR_NOT_IMPLEMENTED;
#endif
}
+
+#endif // USB_FLASH_DRIVE_SUPPORT
\ No newline at end of file
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/message.cpp lib/message.cpp
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/message.cpp 2018-09-21 10:20:15.995647957 -0600
+++ lib/message.cpp 2018-09-19 07:43:46.520339375 -0600
@@ -23,6 +23,9 @@
*/
#include "Usb.h"
+
+#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
+
// 0x80 is the default (i.e. trace) to turn off set this global to something lower.
// this allows for 126 other debugging levels.
// TO-DO: Allow assignment to a different serial port by software
@@ -120,4 +123,6 @@
D_PrintHex<uint8_t > (rcode, 0x80);
Notify(PSTR("\r\n"), 0x80);
}
-#endif
+#endif // DEBUG_USB_HOST
+
+#endif // USB_FLASH_DRIVE_SUPPORT
\ No newline at end of file
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/parsetools.cpp lib/parsetools.cpp
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/parsetools.cpp 2018-09-21 10:21:16.215867769 -0600
+++ lib/parsetools.cpp 2018-09-19 07:43:46.520339375 -0600
@@ -23,6 +23,8 @@
*/
#include "Usb.h"
+#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
+
bool MultiByteValueParser::Parse(uint8_t **pp, uint16_t *pcntdn) {
if(!pBuf) {
Notify(PSTR("Buffer pointer is NULL!\r\n"), 0x80);
@@ -72,3 +74,5 @@
}
return true;
}
+
+#endif // USB_FLASH_DRIVE_SUPPORT
\ No newline at end of file
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/settings.h lib/settings.h
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/settings.h 2018-09-21 10:22:21.792106872 -0600
+++ lib/settings.h 2018-09-21 10:01:53.383594081 -0600
@@ -25,7 +25,21 @@
#ifndef USB_HOST_SHIELD_SETTINGS_H
#define USB_HOST_SHIELD_SETTINGS_H
#include "macros.h"
-
+#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
+ ////////////////////////////////////////////////////////////////////////////////
+ /* Added by Bill Greiman to speed up mass storage initialization with USB
+ * flash drives and simple USB hard drives.
+ * Disable this by defining DELAY(x) to be delay(x).
+ */
+ #define delay(x) if((x) < 200) safe_delay(x)
+ /* Almost all USB flash drives and simple USB hard drives fail the write
+ * protect test and add 20 - 30 seconds to USB init. Set SKIP_WRITE_PROTECT
+ * to nonzero to skip the test and assume the drive is writable.
+ */
+ #define SKIP_WRITE_PROTECT 1
+ /* Since Marlin only cares about USB flash drives, we only need one LUN. */
+ #define MASS_MAX_SUPPORTED_LUN 1
+#endif
////////////////////////////////////////////////////////////////////////////////
// SPI Configuration
////////////////////////////////////////////////////////////////////////////////
@@ -45,6 +59,10 @@
* multiple serial ports are available.
* For example Serial3.
*/
+#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
+ #define USB_HOST_SERIAL MYSERIAL0
+#endif
+
#ifndef USB_HOST_SERIAL
#define USB_HOST_SERIAL Serial
#endif
@@ -99,7 +117,7 @@
// No user serviceable parts below this line.
// DO NOT change anything below here unless you are a developer!
-#include "version_helper.h"
+//#include "version_helper.h"
#if defined(__GNUC__) && defined(__AVR__)
#ifndef GCC_VERSION
@@ -149,7 +167,6 @@
#else
#define USING_SPI4TEENSY3 0
#endif
-
#if ((defined(ARDUINO_SAM_DUE) && defined(__SAM3X8E__)) || defined(__ARDUINO_X86__) || ARDUINO >= 10600) && !USING_SPI4TEENSY3
#include <SPI.h> // Use the Arduino SPI library for the Arduino Due, Intel Galileo 1 & 2, Intel Edison or if the SPI library with transaction is available
#endif
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/UsbCore.h lib/UsbCore.h
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/UsbCore.h 2018-09-21 10:23:09.348280107 -0600
+++ lib/UsbCore.h 2018-09-19 07:43:46.520339375 -0600
@@ -32,7 +32,10 @@
//#define USB_METHODS_INLINE
/* shield pins. First parameter - SS pin, second parameter - INT pin */
-#ifdef BOARD_BLACK_WIDDOW
+
+#if defined(__MARLIN_H__)
+typedef MAX3421e MAX3421E; // Marlin redefines this class in "../usb_host.h"
+#elif defined(BOARD_BLACK_WIDDOW)
typedef MAX3421e<P6, P3> MAX3421E; // Black Widow
#elif defined(CORE_TEENSY) && (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__))
#if EXT_RAM
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/Usb.cpp lib/Usb.cpp
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/Usb.cpp 2018-09-21 10:23:20.732321559 -0600
+++ lib/Usb.cpp 2018-09-19 07:43:46.520339375 -0600
@@ -25,6 +25,8 @@
#include "Usb.h"
+#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
+
static uint8_t usb_error = 0;
static uint8_t usb_task_state;
@@ -825,3 +827,4 @@
}
#endif // defined(USB_METHODS_INLINE)
+#endif // USB_FLASH_DRIVE_SUPPORT
diff -Naur /home/aleph/Downloads/USB_Host_Shield_2.0-master/Usb.h lib/Usb.h
--- /home/aleph/Downloads/USB_Host_Shield_2.0-master/Usb.h 2018-09-21 10:23:33.756368972 -0600
+++ lib/Usb.h 2018-09-19 07:43:46.520339375 -0600
@@ -25,6 +25,8 @@
#ifndef _usb_h_
#define _usb_h_
+#include "../../../Marlin.h"
+
// WARNING: Do not change the order of includes, or stuff will break!
#include <inttypes.h>
#include <stddef.h>
@@ -34,13 +36,15 @@
#include "settings.h"
#include "printhex.h"
#include "message.h"
+
#include "hexdump.h"
-#include "sink_parser.h"
+//#include "sink_parser.h"
#include "max3421e.h"
#include "address.h"
-#include "avrpins.h"
+//#include "avrpins.h"
#include "usb_ch9.h"
-#include "usbhost.h"
+//#include "usbhost.h"
+#include "../usb_host.h"
#include "UsbCore.h"
#include "parsetools.h"
#include "confdescparser.h"

22
config/default/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/3DFabXYZ/Migbot/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/ADIMLab/Granty v2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is required for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/AlephObjects/TAZ4/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Alfawise/U20/Configuration_adv.h
View file

@ -1021,17 +1021,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/AliExpress/UM2pExt/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Anet/A2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Anet/A2plus/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Anet/A6/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Anet/A8/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Anet/A8plus/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Anet/E16/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/AnyCubic/i3/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/ArmEd/Configuration_adv.h
View file

@ -1022,17 +1022,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/BIBO/TouchX/cyclops/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/BIBO/TouchX/default/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/BQ/Hephestos/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/BQ/Hephestos_2/Configuration_adv.h
View file

@ -1026,17 +1026,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/BQ/WITBOX/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Cartesio/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-10/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-10S/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-10_5S/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-10mini/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-20 Pro/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-20/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/CR-8/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/Ender-2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/Ender-3/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/Ender-4/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Creality/Ender-5/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Dagoma/Disco Ultimate/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/EVNOVO (Artillery)/Sidewinder X1/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Einstart-S/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FYSETC/AIO_II/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FYSETC/Cheetah 1.2/BLTouch/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FYSETC/Cheetah 1.2/base/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FYSETC/Cheetah/BLTouch/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FYSETC/Cheetah/base/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

4
config/examples/FYSETC/F6_13/Configuration_adv.h
View file

@ -1027,8 +1027,8 @@
*/
#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#endif
/**

22
config/examples/Felix/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FlashForge/CreatorPro/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/FolgerTech/i3-2020/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Formbot/Raptor/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Formbot/T_Rex_2+/Configuration_adv.h
View file

@ -1022,17 +1022,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Formbot/T_Rex_3/Configuration_adv.h
View file

@ -1022,17 +1022,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Geeetech/A10/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Geeetech/A10M/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Geeetech/A20M/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Geeetech/MeCreator2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Geeetech/Prusa i3 Pro C/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Geeetech/Prusa i3 Pro W/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/HMS434/Configuration_adv.h
View file

@ -1002,17 +1002,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Infitary/i3-M508/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/JGAurora/A1/Configuration_adv.h
View file

@ -1023,17 +1023,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/JGAurora/A5/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/JGAurora/A5S/Configuration_adv.h
View file

@ -1023,17 +1023,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/MakerParts/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Malyan/M150/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Malyan/M200/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Micromake/C1/enhanced/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Mks/Robin/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Mks/Sbase/Configuration_adv.h
View file

@ -1019,17 +1019,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/RapideLite/RL200/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/RigidBot/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/SCARA/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/STM32/Black_STM32F407VET6/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Sanguinololu/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Tevo/Michelangelo/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Tevo/Tarantula Pro/Configuration_adv.h
View file

@ -1014,17 +1014,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Tevo/Tornado/V1 (MKS Base)/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Tevo/Tornado/V2 (MKS GEN-L)/Configuration_adv.h
View file

@ -1017,17 +1017,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/TheBorg/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/TinyBoy2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Tronxy/X3A/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Tronxy/X5S-2E/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/UltiMachine/Archim1/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/UltiMachine/Archim2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/VORONDesign/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Velleman/K8200/Configuration_adv.h
View file

@ -1031,17 +1031,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Velleman/K8400/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/WASP/PowerWASP/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Wanhao/Duplicator 6/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/Wanhao/Duplicator i3 Mini/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/Anycubic/Kossel/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/Dreammaker/Overlord/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/Dreammaker/Overlord_Pro/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/FLSUN/kossel/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/Geeetech/Rostock 301/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/MKS/SBASE/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/Tevo Little Monster/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/generic/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/kossel_mini/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/delta/kossel_xl/Configuration_adv.h
View file

@ -1020,17 +1020,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/gCreate/gMax1.5+/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/makibox/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/tvrrug/Round2/Configuration_adv.h
View file

@ -1018,17 +1018,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**

22
config/examples/wt150/Configuration_adv.h
View file

@ -1019,17 +1019,31 @@
* equivalent MAX3421E breakout board. The USB thumb drive will appear
* to Marlin as an SD card.
*
* The MAX3421E must be assigned the same pins as the SD card reader, with
* The MAX3421E can be assigned the same pins as the SD card reader, with
* the following pin mapping:
*
* SCLK, MOSI, MISO --> SCLK, MOSI, MISO
* INT --> SD_DETECT_PIN
* INT --> SD_DETECT_PIN [1]
* SS --> SDSS
*
* [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
*/
//#define USB_FLASH_DRIVE_SUPPORT
#if ENABLED(USB_FLASH_DRIVE_SUPPORT)
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
#define USB_CS_PIN SDSS
#define USB_INTR_PIN SD_DETECT_PIN
/**
* USB Host Shield Library
*
* - UHS2 uses no interrupts and has been production-tested
* on a LulzBot TAZ Pro with a 32-bit Archim board.
*
* - UHS3 is newer code with better USB compatibility. But it
* is less tested and is known to interfere with Servos.
* [1] This requires USB_INTR_PIN to be interrupt-capable.
*/
//#define USE_UHS3_USB
#endif
/**