visus
/
teensy-core-4.1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Teensy 4.1 core updated for C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
76 Commits
2 Branches
Tree: 351efa83c4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '351efa83c4'
${ noResults }
teensy-core-4.1/teensy3/usb_desc.c

894 lines
44KB
Raw Blame History 

  1. /* Teensyduino Core Library

  2.  * http://www.pjrc.com/teensy/

  3.  * Copyright (c) 2013 PJRC.COM, LLC.

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining

  6.  * a copy of this software and associated documentation files (the

  7.  * "Software"), to deal in the Software without restriction, including

  8.  * without limitation the rights to use, copy, modify, merge, publish,

  9.  * distribute, sublicense, and/or sell copies of the Software, and to

  10.  * permit persons to whom the Software is furnished to do so, subject to

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be 

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows 

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  22.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  */

  30. 

  31. #include "usb_desc.h"

  32. #include "usb_names.h"

  33. #include "mk20dx128.h"

  34. #include "avr_functions.h"

  35. 

  36. // USB Descriptors are binary data which the USB host reads to

  37. // automatically detect a USB device's capabilities.  The format

  38. // and meaning of every field is documented in numerous USB

  39. // standards.  When working with USB descriptors, despite the

  40. // complexity of the standards and poor writing quality in many

  41. // of those documents, remember descriptors are nothing more

  42. // than constant binary data that tells the USB host what the

  43. // device can do.  Computers will load drivers based on this data.

  44. // Those drivers then communicate on the endpoints specified by

  45. // the descriptors.

  46. 

  47. // To configure a new combination of interfaces or make minor

  48. // changes to existing configuration (eg, change the name or ID

  49. // numbers), usually you would edit "usb_desc.h".  This file

  50. // is meant to be configured by the header, so generally it is

  51. // only edited to add completely new USB interfaces or features.

  52. 

  53. 

  54. 

  55. // **************************************************************

  56. //   USB Device

  57. // **************************************************************

  58. 

  59. #define LSB(n) ((n) & 255)

  60. #define MSB(n) (((n) >> 8) & 255)

  61. 

  62. // USB Device Descriptor.  The USB host reads this first, to learn

  63. // what type of device is connected.

  64. static uint8_t device_descriptor[] = {

  65.         18,                                     // bLength

  66.         1,                                      // bDescriptorType

  67.         0x00, 0x02,                             // bcdUSB

  68. #ifdef DEVICE_CLASS

  69.         DEVICE_CLASS,                           // bDeviceClass

  70. #else

  71. 	0,

  72. #endif

  73. #ifdef DEVICE_SUBCLASS

  74.         DEVICE_SUBCLASS,                        // bDeviceSubClass

  75. #else

  76. 	0,

  77. #endif

  78. #ifdef DEVICE_PROTOCOL

  79.         DEVICE_PROTOCOL,                        // bDeviceProtocol

  80. #else

  81. 	0,

  82. #endif

  83.         EP0_SIZE,                               // bMaxPacketSize0

  84.         LSB(VENDOR_ID), MSB(VENDOR_ID),         // idVendor

  85.         LSB(PRODUCT_ID), MSB(PRODUCT_ID),       // idProduct

  86.         0x00, 0x01,                             // bcdDevice

  87.         1,                                      // iManufacturer

  88.         2,                                      // iProduct

  89.         3,                                      // iSerialNumber

  90.         1                                       // bNumConfigurations

  91. };

  92. 

  93. // These descriptors must NOT be "const", because the USB DMA

  94. // has trouble accessing flash memory with enough bandwidth

  95. // while the processor is executing from flash.

  96. 

  97. 

  98. 

  99. // **************************************************************

  100. //   HID Report Descriptors

  101. // **************************************************************

  102. 

  103. // Each HID interface needs a special report descriptor that tells

  104. // the meaning and format of the data.

  105. 

  106. #ifdef KEYBOARD_INTERFACE

  107. // Keyboard Protocol 1, HID 1.11 spec, Appendix B, page 59-60

  108. static uint8_t keyboard_report_desc[] = {

  109.         0x05, 0x01,             //  Usage Page (Generic Desktop),

  110.         0x09, 0x06,             //  Usage (Keyboard),

  111.         0xA1, 0x01,             //  Collection (Application),

  112.         0x75, 0x01,             //  Report Size (1),

  113.         0x95, 0x08,             //  Report Count (8),

  114.         0x05, 0x07,             //  Usage Page (Key Codes),

  115.         0x19, 0xE0,             //  Usage Minimum (224),

  116.         0x29, 0xE7,             //  Usage Maximum (231),

  117.         0x15, 0x00,             //  Logical Minimum (0),

  118.         0x25, 0x01,             //  Logical Maximum (1),

  119.         0x81, 0x02,             //  Input (Data, Variable, Absolute), ;Modifier byte

  120.         0x95, 0x08,             //  Report Count (8),

  121.         0x75, 0x01,             //  Report Size (1),

  122.         0x15, 0x00,             //  Logical Minimum (0),

  123.         0x25, 0x01,             //  Logical Maximum (1),

  124.         0x05, 0x0C,             //  Usage Page (Consumer),

  125.         0x09, 0xE9,             //  Usage (Volume Increment),

  126.         0x09, 0xEA,             //  Usage (Volume Decrement),

  127.         0x09, 0xE2,             //  Usage (Mute),

  128.         0x09, 0xCD,             //  Usage (Play/Pause),

  129.         0x09, 0xB5,             //  Usage (Scan Next Track),

  130.         0x09, 0xB6,             //  Usage (Scan Previous Track),

  131.         0x09, 0xB7,             //  Usage (Stop),

  132.         0x09, 0xB8,             //  Usage (Eject),

  133.         0x81, 0x02,             //  Input (Data, Variable, Absolute), ;Media keys

  134.         0x95, 0x05,             //  Report Count (5),

  135.         0x75, 0x01,             //  Report Size (1),

  136.         0x05, 0x08,             //  Usage Page (LEDs),

  137.         0x19, 0x01,             //  Usage Minimum (1),

  138.         0x29, 0x05,             //  Usage Maximum (5),

  139.         0x91, 0x02,             //  Output (Data, Variable, Absolute), ;LED report

  140.         0x95, 0x01,             //  Report Count (1),

  141.         0x75, 0x03,             //  Report Size (3),

  142.         0x91, 0x03,             //  Output (Constant),                 ;LED report padding

  143.         0x95, 0x06,             //  Report Count (6),

  144.         0x75, 0x08,             //  Report Size (8),

  145.         0x15, 0x00,             //  Logical Minimum (0),

  146.         0x25, 0x7F,             //  Logical Maximum(104),

  147.         0x05, 0x07,             //  Usage Page (Key Codes),

  148.         0x19, 0x00,             //  Usage Minimum (0),

  149.         0x29, 0x7F,             //  Usage Maximum (104),

  150.         0x81, 0x00,             //  Input (Data, Array),                ;Normal keys

  151.         0xc0                    // End Collection

  152. };

  153. #endif

  154. 

  155. #ifdef MOUSE_INTERFACE

  156. // Mouse Protocol 1, HID 1.11 spec, Appendix B, page 59-60, with wheel extension

  157. static uint8_t mouse_report_desc[] = {

  158.         0x05, 0x01,                     // Usage Page (Generic Desktop)

  159.         0x09, 0x02,                     // Usage (Mouse)

  160.         0xA1, 0x01,                     // Collection (Application)

  161.         0x85, 0x01,                     //   REPORT_ID (1)

  162.         0x05, 0x09,                     //   Usage Page (Button)

  163.         0x19, 0x01,                     //   Usage Minimum (Button #1)

  164.         0x29, 0x08,                     //   Usage Maximum (Button #8)

  165.         0x15, 0x00,                     //   Logical Minimum (0)

  166.         0x25, 0x01,                     //   Logical Maximum (1)

  167.         0x95, 0x08,                     //   Report Count (8)

  168.         0x75, 0x01,                     //   Report Size (1)

  169.         0x81, 0x02,                     //   Input (Data, Variable, Absolute)

  170.         0x05, 0x01,                     //   Usage Page (Generic Desktop)

  171.         0x09, 0x30,                     //   Usage (X)

  172.         0x09, 0x31,                     //   Usage (Y)

  173.         0x09, 0x38,                     //   Usage (Wheel)

  174.         0x15, 0x81,                     //   Logical Minimum (-127)

  175.         0x25, 0x7F,                     //   Logical Maximum (127)

  176.         0x75, 0x08,                     //   Report Size (8),

  177.         0x95, 0x03,                     //   Report Count (3),

  178.         0x81, 0x06,                     //   Input (Data, Variable, Relative)

  179.         0xC0,                           // End Collection

  180.         0x05, 0x01,                     // Usage Page (Generic Desktop)

  181.         0x09, 0x02,                     // Usage (Mouse)

  182.         0xA1, 0x01,                     // Collection (Application)

  183.         0x85, 0x02,                     //   REPORT_ID (2)

  184.         0x05, 0x01,                     //   Usage Page (Generic Desktop)

  185.         0x09, 0x30,                     //   Usage (X)

  186.         0x09, 0x31,                     //   Usage (Y)

  187.         0x15, 0x00,                     //   Logical Minimum (0)

  188.         0x26, 0xFF, 0x7F,               //   Logical Maximum (32767)

  189.         0x75, 0x10,                     //   Report Size (16),

  190.         0x95, 0x02,                     //   Report Count (2),

  191.         0x81, 0x02,                     //   Input (Data, Variable, Absolute)

  192.         0xC0                            // End Collection

  193. };

  194. #endif

  195. 

  196. #ifdef JOYSTICK_INTERFACE

  197. static uint8_t joystick_report_desc[] = {

  198.         0x05, 0x01,                     // Usage Page (Generic Desktop)

  199.         0x09, 0x04,                     // Usage (Joystick)

  200.         0xA1, 0x01,                     // Collection (Application)

  201.         0x15, 0x00,                     // Logical Minimum (0)

  202.         0x25, 0x01,                     // Logical Maximum (1)

  203.         0x75, 0x01,                     // Report Size (1)

  204.         0x95, 0x20,                     // Report Count (32)

  205.         0x05, 0x09,                     // Usage Page (Button)

  206.         0x19, 0x01,                     // Usage Minimum (Button #1)

  207.         0x29, 0x20,                     // Usage Maximum (Button #32)

  208.         0x81, 0x02,                     // Input (variable,absolute)

  209.         0x15, 0x00,                     // Logical Minimum (0)

  210.         0x25, 0x07,                     // Logical Maximum (7)

  211.         0x35, 0x00,                     // Physical Minimum (0)

  212.         0x46, 0x3B, 0x01,               // Physical Maximum (315)

  213.         0x75, 0x04,                     // Report Size (4)

  214.         0x95, 0x01,                     // Report Count (1)

  215.         0x65, 0x14,                     // Unit (20)

  216.         0x05, 0x01,                     // Usage Page (Generic Desktop)

  217.         0x09, 0x39,                     // Usage (Hat switch)

  218.         0x81, 0x42,                     // Input (variable,absolute,null_state)

  219.         0x05, 0x01,                     // Usage Page (Generic Desktop)

  220.         0x09, 0x01,                     // Usage (Pointer)

  221.         0xA1, 0x00,                     // Collection ()

  222.         0x15, 0x00,                     //   Logical Minimum (0)

  223.         0x26, 0xFF, 0x03,               //   Logical Maximum (1023)

  224.         0x75, 0x0A,                     //   Report Size (10)

  225.         0x95, 0x04,                     //   Report Count (4)

  226.         0x09, 0x30,                     //   Usage (X)

  227.         0x09, 0x31,                     //   Usage (Y)

  228.         0x09, 0x32,                     //   Usage (Z)

  229.         0x09, 0x35,                     //   Usage (Rz)

  230.         0x81, 0x02,                     //   Input (variable,absolute)

  231.         0xC0,                           // End Collection

  232.         0x15, 0x00,                     // Logical Minimum (0)

  233.         0x26, 0xFF, 0x03,               // Logical Maximum (1023)

  234.         0x75, 0x0A,                     // Report Size (10)

  235.         0x95, 0x02,                     // Report Count (2)

  236.         0x09, 0x36,                     // Usage (Slider)

  237.         0x09, 0x36,                     // Usage (Slider)

  238.         0x81, 0x02,                     // Input (variable,absolute)

  239.         0xC0                            // End Collection

  240. };

  241. #endif

  242. 

  243. #ifdef SEREMU_INTERFACE

  244. static uint8_t seremu_report_desc[] = {

  245.         0x06, 0xC9, 0xFF,                       // Usage Page 0xFFC9 (vendor defined)

  246.         0x09, 0x04,                             // Usage 0x04

  247.         0xA1, 0x5C,                             // Collection 0x5C

  248.         0x75, 0x08,                             // report size = 8 bits (global)

  249.         0x15, 0x00,                             // logical minimum = 0 (global)

  250.         0x26, 0xFF, 0x00,                       // logical maximum = 255 (global)

  251.         0x95, SEREMU_TX_SIZE,                   // report count (global)

  252.         0x09, 0x75,                             // usage (local)

  253.         0x81, 0x02,                             // Input

  254.         0x95, SEREMU_RX_SIZE,                   // report count (global)

  255.         0x09, 0x76,                             // usage (local)

  256.         0x91, 0x02,                             // Output

  257.         0x95, 0x04,                             // report count (global)

  258.         0x09, 0x76,                             // usage (local)

  259.         0xB1, 0x02,                             // Feature

  260.         0xC0                                    // end collection

  261. };

  262. #endif

  263. 

  264. #ifdef RAWHID_INTERFACE

  265. static uint8_t rawhid_report_desc[] = {

  266.         0x06, LSB(RAWHID_USAGE_PAGE), MSB(RAWHID_USAGE_PAGE),

  267.         0x0A, LSB(RAWHID_USAGE), MSB(RAWHID_USAGE),

  268.         0xA1, 0x01,                             // Collection 0x01

  269.         0x75, 0x08,                             // report size = 8 bits

  270.         0x15, 0x00,                             // logical minimum = 0

  271.         0x26, 0xFF, 0x00,                       // logical maximum = 255

  272.         0x95, RAWHID_TX_SIZE,                   // report count

  273.         0x09, 0x01,                             // usage

  274.         0x81, 0x02,                             // Input (array)

  275.         0x95, RAWHID_RX_SIZE,                   // report count

  276.         0x09, 0x02,                             // usage

  277.         0x91, 0x02,                             // Output (array)

  278.         0xC0                                    // end collection

  279. };

  280. #endif

  281. 

  282. #ifdef FLIGHTSIM_INTERFACE

  283. static uint8_t flightsim_report_desc[] = {

  284.         0x06, 0x1C, 0xFF,                       // Usage page = 0xFF1C

  285.         0x0A, 0x39, 0xA7,                       // Usage = 0xA739

  286.         0xA1, 0x01,                             // Collection 0x01

  287.         0x75, 0x08,                             // report size = 8 bits

  288.         0x15, 0x00,                             // logical minimum = 0

  289.         0x26, 0xFF, 0x00,                       // logical maximum = 255

  290.         0x95, FLIGHTSIM_TX_SIZE,                // report count

  291.         0x09, 0x01,                             // usage

  292.         0x81, 0x02,                             // Input (array)

  293.         0x95, FLIGHTSIM_RX_SIZE,                // report count

  294.         0x09, 0x02,                             // usage

  295.         0x91, 0x02,                             // Output (array)

  296.         0xC0                                    // end collection

  297. };

  298. #endif

  299. 

  300. 

  301. 

  302. // **************************************************************

  303. //   USB Configuration

  304. // **************************************************************

  305. 

  306. // USB Configuration Descriptor.  This huge descriptor tells all

  307. // of the devices capbilities.

  308. static uint8_t config_descriptor[CONFIG_DESC_SIZE] = {

  309.         // configuration descriptor, USB spec 9.6.3, page 264-266, Table 9-10

  310.         9,                                      // bLength;

  311.         2,                                      // bDescriptorType;

  312.         LSB(CONFIG_DESC_SIZE),                 // wTotalLength

  313.         MSB(CONFIG_DESC_SIZE),

  314.         NUM_INTERFACE,                          // bNumInterfaces

  315.         1,                                      // bConfigurationValue

  316.         0,                                      // iConfiguration

  317.         0xC0,                                   // bmAttributes

  318.         50,                                     // bMaxPower

  319. 

  320. #ifdef CDC_IAD_DESCRIPTOR

  321.         // interface association descriptor, USB ECN, Table 9-Z

  322.         8,                                      // bLength

  323.         11,                                     // bDescriptorType

  324.         CDC_STATUS_INTERFACE,                   // bFirstInterface

  325.         2,                                      // bInterfaceCount

  326.         0x02,                                   // bFunctionClass

  327.         0x02,                                   // bFunctionSubClass

  328.         0x01,                                   // bFunctionProtocol

  329.         4,                                      // iFunction

  330. #endif

  331. 

  332. #ifdef CDC_DATA_INTERFACE

  333.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  334.         9,                                      // bLength

  335.         4,                                      // bDescriptorType

  336.         CDC_STATUS_INTERFACE,			// bInterfaceNumber

  337.         0,                                      // bAlternateSetting

  338.         1,                                      // bNumEndpoints

  339.         0x02,                                   // bInterfaceClass

  340.         0x02,                                   // bInterfaceSubClass

  341.         0x01,                                   // bInterfaceProtocol

  342.         0,                                      // iInterface

  343.         // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26

  344.         5,                                      // bFunctionLength

  345.         0x24,                                   // bDescriptorType

  346.         0x00,                                   // bDescriptorSubtype

  347.         0x10, 0x01,                             // bcdCDC

  348.         // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27

  349.         5,                                      // bFunctionLength

  350.         0x24,                                   // bDescriptorType

  351.         0x01,                                   // bDescriptorSubtype

  352.         0x01,                                   // bmCapabilities

  353.         1,                                      // bDataInterface

  354.         // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28

  355.         4,                                      // bFunctionLength

  356.         0x24,                                   // bDescriptorType

  357.         0x02,                                   // bDescriptorSubtype

  358.         0x06,                                   // bmCapabilities

  359.         // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33

  360.         5,                                      // bFunctionLength

  361.         0x24,                                   // bDescriptorType

  362.         0x06,                                   // bDescriptorSubtype

  363.         CDC_STATUS_INTERFACE,                   // bMasterInterface

  364.         CDC_DATA_INTERFACE,                     // bSlaveInterface0

  365.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  366.         7,                                      // bLength

  367.         5,                                      // bDescriptorType

  368.         CDC_ACM_ENDPOINT | 0x80,                // bEndpointAddress

  369.         0x03,                                   // bmAttributes (0x03=intr)

  370.         CDC_ACM_SIZE, 0,                        // wMaxPacketSize

  371.         64,                                     // bInterval

  372.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  373.         9,                                      // bLength

  374.         4,                                      // bDescriptorType

  375.         CDC_DATA_INTERFACE,                     // bInterfaceNumber

  376.         0,                                      // bAlternateSetting

  377.         2,                                      // bNumEndpoints

  378.         0x0A,                                   // bInterfaceClass

  379.         0x00,                                   // bInterfaceSubClass

  380.         0x00,                                   // bInterfaceProtocol

  381.         0,                                      // iInterface

  382.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  383.         7,                                      // bLength

  384.         5,                                      // bDescriptorType

  385.         CDC_RX_ENDPOINT,                        // bEndpointAddress

  386.         0x02,                                   // bmAttributes (0x02=bulk)

  387.         CDC_RX_SIZE, 0,                         // wMaxPacketSize

  388.         0,                                      // bInterval

  389.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  390.         7,                                      // bLength

  391.         5,                                      // bDescriptorType

  392.         CDC_TX_ENDPOINT | 0x80,                 // bEndpointAddress

  393.         0x02,                                   // bmAttributes (0x02=bulk)

  394.         CDC_TX_SIZE, 0,                         // wMaxPacketSize

  395.         0,                                      // bInterval

  396. #endif // CDC_DATA_INTERFACE

  397. 

  398. #ifdef MIDI_INTERFACE

  399.         // Standard MS Interface Descriptor,

  400.         9,                                      // bLength

  401.         4,                                      // bDescriptorType

  402.         MIDI_INTERFACE,                         // bInterfaceNumber

  403.         0,                                      // bAlternateSetting

  404.         2,                                      // bNumEndpoints

  405.         0x01,                                   // bInterfaceClass (0x01 = Audio)

  406.         0x03,                                   // bInterfaceSubClass (0x03 = MIDI)

  407.         0x00,                                   // bInterfaceProtocol (unused for MIDI)

  408.         0,                                      // iInterface

  409.         // MIDI MS Interface Header, USB MIDI 6.1.2.1, page 21, Table 6-2

  410.         7,                                      // bLength

  411.         0x24,                                   // bDescriptorType = CS_INTERFACE

  412.         0x01,                                   // bDescriptorSubtype = MS_HEADER 

  413.         0x00, 0x01,                             // bcdMSC = revision 01.00

  414.         0x41, 0x00,                             // wTotalLength

  415.         // MIDI IN Jack Descriptor, B.4.3, Table B-7 (embedded), page 40

  416.         6,                                      // bLength

  417.         0x24,                                   // bDescriptorType = CS_INTERFACE

  418.         0x02,                                   // bDescriptorSubtype = MIDI_IN_JACK

  419.         0x01,                                   // bJackType = EMBEDDED

  420.         1,                                      // bJackID, ID = 1

  421.         0,                                      // iJack

  422.         // MIDI IN Jack Descriptor, B.4.3, Table B-8 (external), page 40

  423.         6,                                      // bLength

  424.         0x24,                                   // bDescriptorType = CS_INTERFACE

  425.         0x02,                                   // bDescriptorSubtype = MIDI_IN_JACK

  426.         0x02,                                   // bJackType = EXTERNAL

  427.         2,                                      // bJackID, ID = 2

  428.         0,                                      // iJack

  429.         // MIDI OUT Jack Descriptor, B.4.4, Table B-9, page 41

  430.         9,

  431.         0x24,                                   // bDescriptorType = CS_INTERFACE

  432.         0x03,                                   // bDescriptorSubtype = MIDI_OUT_JACK

  433.         0x01,                                   // bJackType = EMBEDDED

  434.         3,                                      // bJackID, ID = 3

  435.         1,                                      // bNrInputPins = 1 pin

  436.         2,                                      // BaSourceID(1) = 2

  437.         1,                                      // BaSourcePin(1) = first pin

  438.         0,                                      // iJack

  439.         // MIDI OUT Jack Descriptor, B.4.4, Table B-10, page 41

  440.         9,

  441.         0x24,                                   // bDescriptorType = CS_INTERFACE

  442.         0x03,                                   // bDescriptorSubtype = MIDI_OUT_JACK

  443.         0x02,                                   // bJackType = EXTERNAL

  444.         4,                                      // bJackID, ID = 4

  445.         1,                                      // bNrInputPins = 1 pin

  446.         1,                                      // BaSourceID(1) = 1

  447.         1,                                      // BaSourcePin(1) = first pin

  448.         0,                                      // iJack

  449.         // Standard Bulk OUT Endpoint Descriptor, B.5.1, Table B-11, pae 42

  450.         9,                                      // bLength

  451.         5,                                      // bDescriptorType = ENDPOINT 

  452.         MIDI_RX_ENDPOINT,                       // bEndpointAddress

  453.         0x02,                                   // bmAttributes (0x02=bulk)

  454.         MIDI_RX_SIZE, 0,                        // wMaxPacketSize

  455.         0,                                      // bInterval

  456.         0,                                      // bRefresh

  457.         0,                                      // bSynchAddress

  458.         // Class-specific MS Bulk OUT Endpoint Descriptor, B.5.2, Table B-12, page 42

  459.         5,                                      // bLength

  460.         0x25,                                   // bDescriptorSubtype = CS_ENDPOINT

  461.         0x01,                                   // bJackType = MS_GENERAL

  462.         1,                                      // bNumEmbMIDIJack = 1 jack

  463.         1,                                      // BaAssocJackID(1) = jack ID #1

  464.         // Standard Bulk IN Endpoint Descriptor, B.5.1, Table B-11, pae 42

  465.         9,                                      // bLength

  466.         5,                                      // bDescriptorType = ENDPOINT 

  467.         MIDI_TX_ENDPOINT | 0x80,                // bEndpointAddress

  468.         0x02,                                   // bmAttributes (0x02=bulk)

  469.         MIDI_TX_SIZE, 0,                        // wMaxPacketSize

  470.         0,                                      // bInterval

  471.         0,                                      // bRefresh

  472.         0,                                      // bSynchAddress

  473.         // Class-specific MS Bulk IN Endpoint Descriptor, B.5.2, Table B-12, page 42

  474.         5,                                      // bLength

  475.         0x25,                                   // bDescriptorSubtype = CS_ENDPOINT

  476.         0x01,                                   // bJackType = MS_GENERAL

  477.         1,                                      // bNumEmbMIDIJack = 1 jack

  478.         3,                                      // BaAssocJackID(1) = jack ID #3

  479. #endif // MIDI_INTERFACE

  480. 

  481. #ifdef KEYBOARD_INTERFACE

  482.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  483.         9,                                      // bLength

  484.         4,                                      // bDescriptorType

  485.         KEYBOARD_INTERFACE,                     // bInterfaceNumber

  486.         0,                                      // bAlternateSetting

  487.         1,                                      // bNumEndpoints

  488.         0x03,                                   // bInterfaceClass (0x03 = HID)

  489.         0x01,                                   // bInterfaceSubClass (0x01 = Boot)

  490.         0x01,                                   // bInterfaceProtocol (0x01 = Keyboard)

  491.         0,                                      // iInterface

  492.         // HID interface descriptor, HID 1.11 spec, section 6.2.1

  493.         9,                                      // bLength

  494.         0x21,                                   // bDescriptorType

  495.         0x11, 0x01,                             // bcdHID

  496.         0,                                      // bCountryCode

  497.         1,                                      // bNumDescriptors

  498.         0x22,                                   // bDescriptorType

  499.         LSB(sizeof(keyboard_report_desc)),      // wDescriptorLength

  500.         MSB(sizeof(keyboard_report_desc)),

  501.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  502.         7,                                      // bLength

  503.         5,                                      // bDescriptorType

  504.         KEYBOARD_ENDPOINT | 0x80,               // bEndpointAddress

  505.         0x03,                                   // bmAttributes (0x03=intr)

  506.         KEYBOARD_SIZE, 0,                       // wMaxPacketSize

  507.         KEYBOARD_INTERVAL,                      // bInterval

  508. #endif // KEYBOARD_INTERFACE

  509. 

  510. #ifdef MOUSE_INTERFACE

  511.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  512.         9,                                      // bLength

  513.         4,                                      // bDescriptorType

  514.         MOUSE_INTERFACE,                        // bInterfaceNumber

  515.         0,                                      // bAlternateSetting

  516.         1,                                      // bNumEndpoints

  517.         0x03,                                   // bInterfaceClass (0x03 = HID)

  518.         0x00,                                   // bInterfaceSubClass (0x01 = Boot)

  519.         0x00,                                   // bInterfaceProtocol (0x02 = Mouse)

  520.         0,                                      // iInterface

  521.         // HID interface descriptor, HID 1.11 spec, section 6.2.1

  522.         9,                                      // bLength

  523.         0x21,                                   // bDescriptorType

  524.         0x11, 0x01,                             // bcdHID

  525.         0,                                      // bCountryCode

  526.         1,                                      // bNumDescriptors

  527.         0x22,                                   // bDescriptorType

  528.         LSB(sizeof(mouse_report_desc)),         // wDescriptorLength

  529.         MSB(sizeof(mouse_report_desc)),

  530.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  531.         7,                                      // bLength

  532.         5,                                      // bDescriptorType

  533.         MOUSE_ENDPOINT | 0x80,                  // bEndpointAddress

  534.         0x03,                                   // bmAttributes (0x03=intr)

  535.         MOUSE_SIZE, 0,                          // wMaxPacketSize

  536.         MOUSE_INTERVAL,                         // bInterval

  537. #endif // MOUSE_INTERFACE

  538. 

  539. #ifdef RAWHID_INTERFACE

  540.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  541.         9,                                      // bLength

  542.         4,                                      // bDescriptorType

  543.         RAWHID_INTERFACE,                       // bInterfaceNumber

  544.         0,                                      // bAlternateSetting

  545.         2,                                      // bNumEndpoints

  546.         0x03,                                   // bInterfaceClass (0x03 = HID)

  547.         0x00,                                   // bInterfaceSubClass

  548.         0x00,                                   // bInterfaceProtocol

  549.         0,                                      // iInterface

  550.         // HID interface descriptor, HID 1.11 spec, section 6.2.1

  551.         9,                                      // bLength

  552.         0x21,                                   // bDescriptorType

  553.         0x11, 0x01,                             // bcdHID

  554.         0,                                      // bCountryCode

  555.         1,                                      // bNumDescriptors

  556.         0x22,                                   // bDescriptorType

  557.         LSB(sizeof(rawhid_report_desc)),        // wDescriptorLength

  558.         MSB(sizeof(rawhid_report_desc)),

  559.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  560.         7,                                      // bLength

  561.         5,                                      // bDescriptorType

  562.         RAWHID_TX_ENDPOINT | 0x80,              // bEndpointAddress

  563.         0x03,                                   // bmAttributes (0x03=intr)

  564.         RAWHID_TX_SIZE, 0,                      // wMaxPacketSize

  565.         RAWHID_TX_INTERVAL,                     // bInterval

  566.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  567.         7,                                      // bLength

  568.         5,                                      // bDescriptorType

  569.         RAWHID_RX_ENDPOINT,                     // bEndpointAddress

  570.         0x03,                                   // bmAttributes (0x03=intr)

  571.         RAWHID_RX_SIZE, 0,                      // wMaxPacketSize

  572.         RAWHID_RX_INTERVAL,			// bInterval

  573. #endif // RAWHID_INTERFACE

  574. 

  575. #ifdef FLIGHTSIM_INTERFACE

  576.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  577.         9,                                      // bLength

  578.         4,                                      // bDescriptorType

  579.         FLIGHTSIM_INTERFACE,                    // bInterfaceNumber

  580.         0,                                      // bAlternateSetting

  581.         2,                                      // bNumEndpoints

  582.         0x03,                                   // bInterfaceClass (0x03 = HID)

  583.         0x00,                                   // bInterfaceSubClass

  584.         0x00,                                   // bInterfaceProtocol

  585.         0,                                      // iInterface

  586.         // HID interface descriptor, HID 1.11 spec, section 6.2.1

  587.         9,                                      // bLength

  588.         0x21,                                   // bDescriptorType

  589.         0x11, 0x01,                             // bcdHID

  590.         0,                                      // bCountryCode

  591.         1,                                      // bNumDescriptors

  592.         0x22,                                   // bDescriptorType

  593.         LSB(sizeof(flightsim_report_desc)),     // wDescriptorLength

  594.         MSB(sizeof(flightsim_report_desc)),

  595.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  596.         7,                                      // bLength

  597.         5,                                      // bDescriptorType

  598.         FLIGHTSIM_TX_ENDPOINT | 0x80,           // bEndpointAddress

  599.         0x03,                                   // bmAttributes (0x03=intr)

  600.         FLIGHTSIM_TX_SIZE, 0,                   // wMaxPacketSize

  601.         FLIGHTSIM_TX_INTERVAL,                  // bInterval

  602.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  603.         7,                                      // bLength

  604.         5,                                      // bDescriptorType

  605.         FLIGHTSIM_RX_ENDPOINT,                  // bEndpointAddress

  606.         0x03,                                   // bmAttributes (0x03=intr)

  607.         FLIGHTSIM_RX_SIZE, 0,                   // wMaxPacketSize

  608.         FLIGHTSIM_RX_INTERVAL,			// bInterval

  609. #endif // FLIGHTSIM_INTERFACE

  610. 

  611. #ifdef SEREMU_INTERFACE

  612.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  613.         9,                                      // bLength

  614.         4,                                      // bDescriptorType

  615.         SEREMU_INTERFACE,                       // bInterfaceNumber

  616.         0,                                      // bAlternateSetting

  617.         2,                                      // bNumEndpoints

  618.         0x03,                                   // bInterfaceClass (0x03 = HID)

  619.         0x00,                                   // bInterfaceSubClass

  620.         0x00,                                   // bInterfaceProtocol

  621.         0,                                      // iInterface

  622.         // HID interface descriptor, HID 1.11 spec, section 6.2.1

  623.         9,                                      // bLength

  624.         0x21,                                   // bDescriptorType

  625.         0x11, 0x01,                             // bcdHID

  626.         0,                                      // bCountryCode

  627.         1,                                      // bNumDescriptors

  628.         0x22,                                   // bDescriptorType

  629.         LSB(sizeof(seremu_report_desc)),        // wDescriptorLength

  630.         MSB(sizeof(seremu_report_desc)),

  631.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  632.         7,                                      // bLength

  633.         5,                                      // bDescriptorType

  634.         SEREMU_TX_ENDPOINT | 0x80,              // bEndpointAddress

  635.         0x03,                                   // bmAttributes (0x03=intr)

  636.         SEREMU_TX_SIZE, 0,                      // wMaxPacketSize

  637.         SEREMU_TX_INTERVAL,                     // bInterval

  638.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  639.         7,                                      // bLength

  640.         5,                                      // bDescriptorType

  641.         SEREMU_RX_ENDPOINT,                     // bEndpointAddress

  642.         0x03,                                   // bmAttributes (0x03=intr)

  643.         SEREMU_RX_SIZE, 0,                      // wMaxPacketSize

  644.         SEREMU_RX_INTERVAL,			// bInterval

  645. #endif // SEREMU_INTERFACE

  646. 

  647. #ifdef JOYSTICK_INTERFACE

  648.         // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12

  649.         9,                                      // bLength

  650.         4,                                      // bDescriptorType

  651.         JOYSTICK_INTERFACE,                     // bInterfaceNumber

  652.         0,                                      // bAlternateSetting

  653.         1,                                      // bNumEndpoints

  654.         0x03,                                   // bInterfaceClass (0x03 = HID)

  655.         0x00,                                   // bInterfaceSubClass

  656.         0x00,                                   // bInterfaceProtocol

  657.         0,                                      // iInterface

  658.         // HID interface descriptor, HID 1.11 spec, section 6.2.1

  659.         9,                                      // bLength

  660.         0x21,                                   // bDescriptorType

  661.         0x11, 0x01,                             // bcdHID

  662.         0,                                      // bCountryCode

  663.         1,                                      // bNumDescriptors

  664.         0x22,                                   // bDescriptorType

  665.         LSB(sizeof(joystick_report_desc)),      // wDescriptorLength

  666.         MSB(sizeof(joystick_report_desc)),

  667.         // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13

  668.         7,                                      // bLength

  669.         5,                                      // bDescriptorType

  670.         JOYSTICK_ENDPOINT | 0x80,               // bEndpointAddress

  671.         0x03,                                   // bmAttributes (0x03=intr)

  672.         JOYSTICK_SIZE, 0,                       // wMaxPacketSize

  673.         JOYSTICK_INTERVAL,                      // bInterval

  674. #endif // JOYSTICK_INTERFACE

  675. 

  676. };

  677. 

  678. 

  679. // **************************************************************

  680. //   String Descriptors

  681. // **************************************************************

  682. 

  683. // The descriptors above can provide human readable strings,

  684. // referenced by index numbers.  These descriptors are the

  685. // actual string data

  686. 

  687. /* defined in usb_names.h

  688. struct usb_string_descriptor_struct {

  689.         uint8_t bLength;

  690.         uint8_t bDescriptorType;

  691.         uint16_t wString[];

  692. };

  693. */

  694. 

  695. extern struct usb_string_descriptor_struct usb_string_manufacturer_name

  696.         __attribute__ ((weak, alias("usb_string_manufacturer_name_default")));

  697. extern struct usb_string_descriptor_struct usb_string_product_name

  698.         __attribute__ ((weak, alias("usb_string_product_name_default")));

  699. extern struct usb_string_descriptor_struct usb_string_serial_number

  700.         __attribute__ ((weak, alias("usb_string_serial_number_default")));

  701. 

  702. struct usb_string_descriptor_struct string0 = {

  703.         4,

  704.         3,

  705.         {0x0409}

  706. };

  707. 

  708. struct usb_string_descriptor_struct usb_string_manufacturer_name_default = {

  709.         2 + MANUFACTURER_NAME_LEN * 2,

  710.         3,

  711.         MANUFACTURER_NAME

  712. };

  713. struct usb_string_descriptor_struct usb_string_product_name_default = {

  714. 	2 + PRODUCT_NAME_LEN * 2,

  715.         3,

  716.         PRODUCT_NAME

  717. };

  718. struct usb_string_descriptor_struct usb_string_serial_number_default = {

  719.         12,

  720.         3,

  721.         {0,0,0,0,0,0,0,0,0,0}

  722. };

  723. 

  724. void usb_init_serialnumber(void)

  725. {

  726. 	char buf[11];

  727. 	uint32_t i, num;

  728. 

  729. 	__disable_irq();

  730. 	FTFL_FSTAT = FTFL_FSTAT_RDCOLERR | FTFL_FSTAT_ACCERR | FTFL_FSTAT_FPVIOL;

  731. 	FTFL_FCCOB0 = 0x41;

  732. 	FTFL_FCCOB1 = 15;

  733. 	FTFL_FSTAT = FTFL_FSTAT_CCIF;

  734. 	while (!(FTFL_FSTAT & FTFL_FSTAT_CCIF)) ; // wait

  735. 	num = *(uint32_t *)&FTFL_FCCOB7;

  736. 	__enable_irq();

  737. 	// add extra zero to work around OS-X CDC-ACM driver bug

  738. 	if (num < 10000000) num = num * 10;

  739. 	ultoa(num, buf, 10);

  740. 	for (i=0; i<10; i++) {

  741. 		char c = buf[i];

  742. 		if (!c) break;

  743. 		usb_string_serial_number_default.wString[i] = c;

  744. 	}

  745. 	usb_string_serial_number_default.bLength = i * 2 + 2;

  746. }

  747. 

  748. 

  749. // **************************************************************

  750. //   Descriptors List

  751. // **************************************************************

  752. 

  753. // This table provides access to all the descriptor data above.

  754. 

  755. const usb_descriptor_list_t usb_descriptor_list[] = {

  756. 	//wValue, wIndex, address,          length

  757. 	{0x0100, 0x0000, device_descriptor, sizeof(device_descriptor)},

  758. 	{0x0200, 0x0000, config_descriptor, sizeof(config_descriptor)},

  759. #ifdef SEREMU_INTERFACE

  760. 	{0x2200, SEREMU_INTERFACE, seremu_report_desc, sizeof(seremu_report_desc)},

  761. 	{0x2100, SEREMU_INTERFACE, config_descriptor+SEREMU_DESC_OFFSET, 9},

  762. #endif

  763. #ifdef KEYBOARD_INTERFACE

  764.         {0x2200, KEYBOARD_INTERFACE, keyboard_report_desc, sizeof(keyboard_report_desc)},

  765.         {0x2100, KEYBOARD_INTERFACE, config_descriptor+KEYBOARD_DESC_OFFSET, 9},

  766. #endif

  767. #ifdef MOUSE_INTERFACE

  768.         {0x2200, MOUSE_INTERFACE, mouse_report_desc, sizeof(mouse_report_desc)},

  769.         {0x2100, MOUSE_INTERFACE, config_descriptor+MOUSE_DESC_OFFSET, 9},

  770. #endif

  771. #ifdef JOYSTICK_INTERFACE

  772.         {0x2200, JOYSTICK_INTERFACE, joystick_report_desc, sizeof(joystick_report_desc)},

  773.         {0x2100, JOYSTICK_INTERFACE, config_descriptor+JOYSTICK_DESC_OFFSET, 9},

  774. #endif

  775. #ifdef RAWHID_INTERFACE

  776. 	{0x2200, RAWHID_INTERFACE, rawhid_report_desc, sizeof(rawhid_report_desc)},

  777. 	{0x2100, RAWHID_INTERFACE, config_descriptor+RAWHID_DESC_OFFSET, 9},

  778. #endif

  779. #ifdef FLIGHTSIM_INTERFACE

  780. 	{0x2200, FLIGHTSIM_INTERFACE, flightsim_report_desc, sizeof(flightsim_report_desc)},

  781. 	{0x2100, FLIGHTSIM_INTERFACE, config_descriptor+FLIGHTSIM_DESC_OFFSET, 9},

  782. #endif

  783.         {0x0300, 0x0000, (const uint8_t *)&string0, 0},

  784.         {0x0301, 0x0409, (const uint8_t *)&usb_string_manufacturer_name, 0},

  785.         {0x0302, 0x0409, (const uint8_t *)&usb_string_product_name, 0},

  786.         {0x0303, 0x0409, (const uint8_t *)&usb_string_serial_number, 0},

  787.         //{0x0301, 0x0409, (const uint8_t *)&string1, 0},

  788.         //{0x0302, 0x0409, (const uint8_t *)&string2, 0},

  789.         //{0x0303, 0x0409, (const uint8_t *)&string3, 0},

  790. 	{0, 0, NULL, 0}

  791. };

  792. 

  793. 

  794. // **************************************************************

  795. //   Endpoint Configuration

  796. // **************************************************************

  797. 

  798. #if 0

  799. // 0x00 = not used

  800. // 0x19 = Recieve only

  801. // 0x15 = Transmit only

  802. // 0x1D = Transmit & Recieve

  803. // 

  804. const uint8_t usb_endpoint_config_table[NUM_ENDPOINTS] = 

  805. {

  806. 	0x00, 0x15, 0x19, 0x15, 0x00, 0x00, 0x00, 0x00, 

  807. 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 

  808. };

  809. #endif

  810. 

  811. 

  812. const uint8_t usb_endpoint_config_table[NUM_ENDPOINTS] = 

  813. {

  814. #if (defined(ENDPOINT1_CONFIG) && NUM_ENDPOINTS >= 1)

  815. 	ENDPOINT1_CONFIG,

  816. #elif (NUM_ENDPOINTS >= 1)

  817. 	ENDPOINT_UNUSED,

  818. #endif

  819. #if (defined(ENDPOINT2_CONFIG) && NUM_ENDPOINTS >= 2)

  820. 	ENDPOINT2_CONFIG,

  821. #elif (NUM_ENDPOINTS >= 2)

  822. 	ENDPOINT_UNUSED,

  823. #endif

  824. #if (defined(ENDPOINT3_CONFIG) && NUM_ENDPOINTS >= 3)

  825. 	ENDPOINT3_CONFIG,

  826. #elif (NUM_ENDPOINTS >= 3)

  827. 	ENDPOINT_UNUSED,

  828. #endif

  829. #if (defined(ENDPOINT4_CONFIG) && NUM_ENDPOINTS >= 4)

  830. 	ENDPOINT4_CONFIG,

  831. #elif (NUM_ENDPOINTS >= 4)

  832. 	ENDPOINT_UNUSED,

  833. #endif

  834. #if (defined(ENDPOINT5_CONFIG) && NUM_ENDPOINTS >= 5)

  835. 	ENDPOINT5_CONFIG,

  836. #elif (NUM_ENDPOINTS >= 5)

  837. 	ENDPOINT_UNUSED,

  838. #endif

  839. #if (defined(ENDPOINT6_CONFIG) && NUM_ENDPOINTS >= 6)

  840. 	ENDPOINT6_CONFIG,

  841. #elif (NUM_ENDPOINTS >= 6)

  842. 	ENDPOINT_UNUSED,

  843. #endif

  844. #if (defined(ENDPOINT7_CONFIG) && NUM_ENDPOINTS >= 7)

  845. 	ENDPOINT7_CONFIG,

  846. #elif (NUM_ENDPOINTS >= 7)

  847. 	ENDPOINT_UNUSED,

  848. #endif

  849. #if (defined(ENDPOINT8_CONFIG) && NUM_ENDPOINTS >= 8)

  850. 	ENDPOINT8_CONFIG,

  851. #elif (NUM_ENDPOINTS >= 8)

  852. 	ENDPOINT_UNUSED,

  853. #endif

  854. #if (defined(ENDPOINT9_CONFIG) && NUM_ENDPOINTS >= 9)

  855. 	ENDPOINT9_CONFIG,

  856. #elif (NUM_ENDPOINTS >= 9)

  857. 	ENDPOINT_UNUSED,

  858. #endif

  859. #if (defined(ENDPOINT10_CONFIG) && NUM_ENDPOINTS >= 10)

  860. 	ENDPOINT10_CONFIG,

  861. #elif (NUM_ENDPOINTS >= 10)

  862. 	ENDPOINT_UNUSED,

  863. #endif

  864. #if (defined(ENDPOINT11_CONFIG) && NUM_ENDPOINTS >= 11)

  865. 	ENDPOINT11_CONFIG,

  866. #elif (NUM_ENDPOINTS >= 11)

  867. 	ENDPOINT_UNUSED,

  868. #endif

  869. #if (defined(ENDPOINT12_CONFIG) && NUM_ENDPOINTS >= 12)

  870. 	ENDPOINT12_CONFIG,

  871. #elif (NUM_ENDPOINTS >= 12)

  872. 	ENDPOINT_UNUSED,

  873. #endif

  874. #if (defined(ENDPOINT13_CONFIG) && NUM_ENDPOINTS >= 13)

  875. 	ENDPOINT13_CONFIG,

  876. #elif (NUM_ENDPOINTS >= 13)

  877. 	ENDPOINT_UNUSED,

  878. #endif

  879. #if (defined(ENDPOINT14_CONFIG) && NUM_ENDPOINTS >= 14)

  880. 	ENDPOINT14_CONFIG,

  881. #elif (NUM_ENDPOINTS >= 14)

  882. 	ENDPOINT_UNUSED,

  883. #endif

  884. #if (defined(ENDPOINT15_CONFIG) && NUM_ENDPOINTS >= 15)

  885. 	ENDPOINT15_CONFIG,

  886. #elif (NUM_ENDPOINTS >= 15)

  887. 	ENDPOINT_UNUSED,

  888. #endif

  889. };

  890. 

  891. 

  892.