USBKeyboard.cpp

00001 /*
00002  * Copyright (c) 2018-2019, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 #include "stdint.h"
00019 
00020 #include "USBKeyboard.h"
00021 #include "usb_phy_api.h"
00022 
00023 #define REPORT_ID_KEYBOARD 1
00024 #define REPORT_ID_VOLUME   3
00025 
00026 
00027 typedef struct {
00028     unsigned char usage;
00029     unsigned char modifier;
00030 } KEYMAP;
00031 
00032 #ifdef US_KEYBOARD
00033 /* US keyboard (as HID standard) */
00034 #define KEYMAP_SIZE (152)
00035 const KEYMAP keymap[KEYMAP_SIZE] = {
00036     {0, 0},             /* NUL */
00037     {0, 0},             /* SOH */
00038     {0, 0},             /* STX */
00039     {0, 0},             /* ETX */
00040     {0, 0},             /* EOT */
00041     {0, 0},             /* ENQ */
00042     {0, 0},             /* ACK */
00043     {0, 0},             /* BEL */
00044     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
00045     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
00046     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
00047     {0, 0},             /* VT  */
00048     {0, 0},             /* FF  */
00049     {0, 0},             /* CR  */
00050     {0, 0},             /* SO  */
00051     {0, 0},             /* SI  */
00052     {0, 0},             /* DEL */
00053     {0, 0},             /* DC1 */
00054     {0, 0},             /* DC2 */
00055     {0, 0},             /* DC3 */
00056     {0, 0},             /* DC4 */
00057     {0, 0},             /* NAK */
00058     {0, 0},             /* SYN */
00059     {0, 0},             /* ETB */
00060     {0, 0},             /* CAN */
00061     {0, 0},             /* EM  */
00062     {0, 0},             /* SUB */
00063     {0, 0},             /* ESC */
00064     {0, 0},             /* FS  */
00065     {0, 0},             /* GS  */
00066     {0, 0},             /* RS  */
00067     {0, 0},             /* US  */
00068     {0x2c, 0},          /*   */
00069     {0x1e, KEY_SHIFT},      /* ! */
00070     {0x34, KEY_SHIFT},      /* " */
00071     {0x20, KEY_SHIFT},      /* # */
00072     {0x21, KEY_SHIFT},      /* $ */
00073     {0x22, KEY_SHIFT},      /* % */
00074     {0x24, KEY_SHIFT},      /* & */
00075     {0x34, 0},          /* ' */
00076     {0x26, KEY_SHIFT},      /* ( */
00077     {0x27, KEY_SHIFT},      /* ) */
00078     {0x25, KEY_SHIFT},      /* * */
00079     {0x2e, KEY_SHIFT},      /* + */
00080     {0x36, 0},          /* , */
00081     {0x2d, 0},          /* - */
00082     {0x37, 0},          /* . */
00083     {0x38, 0},          /* / */
00084     {0x27, 0},          /* 0 */
00085     {0x1e, 0},          /* 1 */
00086     {0x1f, 0},          /* 2 */
00087     {0x20, 0},          /* 3 */
00088     {0x21, 0},          /* 4 */
00089     {0x22, 0},          /* 5 */
00090     {0x23, 0},          /* 6 */
00091     {0x24, 0},          /* 7 */
00092     {0x25, 0},          /* 8 */
00093     {0x26, 0},          /* 9 */
00094     {0x33, KEY_SHIFT},      /* : */
00095     {0x33, 0},          /* ; */
00096     {0x36, KEY_SHIFT},      /* < */
00097     {0x2e, 0},          /* = */
00098     {0x37, KEY_SHIFT},      /* > */
00099     {0x38, KEY_SHIFT},      /* ? */
00100     {0x1f, KEY_SHIFT},      /* @ */
00101     {0x04, KEY_SHIFT},      /* A */
00102     {0x05, KEY_SHIFT},      /* B */
00103     {0x06, KEY_SHIFT},      /* C */
00104     {0x07, KEY_SHIFT},      /* D */
00105     {0x08, KEY_SHIFT},      /* E */
00106     {0x09, KEY_SHIFT},      /* F */
00107     {0x0a, KEY_SHIFT},      /* G */
00108     {0x0b, KEY_SHIFT},      /* H */
00109     {0x0c, KEY_SHIFT},      /* I */
00110     {0x0d, KEY_SHIFT},      /* J */
00111     {0x0e, KEY_SHIFT},      /* K */
00112     {0x0f, KEY_SHIFT},      /* L */
00113     {0x10, KEY_SHIFT},      /* M */
00114     {0x11, KEY_SHIFT},      /* N */
00115     {0x12, KEY_SHIFT},      /* O */
00116     {0x13, KEY_SHIFT},      /* P */
00117     {0x14, KEY_SHIFT},      /* Q */
00118     {0x15, KEY_SHIFT},      /* R */
00119     {0x16, KEY_SHIFT},      /* S */
00120     {0x17, KEY_SHIFT},      /* T */
00121     {0x18, KEY_SHIFT},      /* U */
00122     {0x19, KEY_SHIFT},      /* V */
00123     {0x1a, KEY_SHIFT},      /* W */
00124     {0x1b, KEY_SHIFT},      /* X */
00125     {0x1c, KEY_SHIFT},      /* Y */
00126     {0x1d, KEY_SHIFT},      /* Z */
00127     {0x2f, 0},          /* [ */
00128     {0x31, 0},          /* \ */
00129     {0x30, 0},          /* ] */
00130     {0x23, KEY_SHIFT},      /* ^ */
00131     {0x2d, KEY_SHIFT},      /* _ */
00132     {0x35, 0},          /* ` */
00133     {0x04, 0},          /* a */
00134     {0x05, 0},          /* b */
00135     {0x06, 0},          /* c */
00136     {0x07, 0},          /* d */
00137     {0x08, 0},          /* e */
00138     {0x09, 0},          /* f */
00139     {0x0a, 0},          /* g */
00140     {0x0b, 0},          /* h */
00141     {0x0c, 0},          /* i */
00142     {0x0d, 0},          /* j */
00143     {0x0e, 0},          /* k */
00144     {0x0f, 0},          /* l */
00145     {0x10, 0},          /* m */
00146     {0x11, 0},          /* n */
00147     {0x12, 0},          /* o */
00148     {0x13, 0},          /* p */
00149     {0x14, 0},          /* q */
00150     {0x15, 0},          /* r */
00151     {0x16, 0},          /* s */
00152     {0x17, 0},          /* t */
00153     {0x18, 0},          /* u */
00154     {0x19, 0},          /* v */
00155     {0x1a, 0},          /* w */
00156     {0x1b, 0},          /* x */
00157     {0x1c, 0},          /* y */
00158     {0x1d, 0},          /* z */
00159     {0x2f, KEY_SHIFT},      /* { */
00160     {0x31, KEY_SHIFT},      /* | */
00161     {0x30, KEY_SHIFT},      /* } */
00162     {0x35, KEY_SHIFT},      /* ~ */
00163     {0, 0},             /* DEL */
00164 
00165     {0x3a, 0},          /* F1 */
00166     {0x3b, 0},          /* F2 */
00167     {0x3c, 0},          /* F3 */
00168     {0x3d, 0},          /* F4 */
00169     {0x3e, 0},          /* F5 */
00170     {0x3f, 0},          /* F6 */
00171     {0x40, 0},          /* F7 */
00172     {0x41, 0},          /* F8 */
00173     {0x42, 0},          /* F9 */
00174     {0x43, 0},          /* F10 */
00175     {0x44, 0},          /* F11 */
00176     {0x45, 0},          /* F12 */
00177 
00178     {0x46, 0},          /* PRINT_SCREEN */
00179     {0x47, 0},          /* SCROLL_LOCK */
00180     {0x39, 0},          /* CAPS_LOCK */
00181     {0x53, 0},          /* NUM_LOCK */
00182     {0x49, 0},          /* INSERT */
00183     {0x4a, 0},          /* HOME */
00184     {0x4b, 0},          /* PAGE_UP */
00185     {0x4e, 0},          /* PAGE_DOWN */
00186 
00187     {0x4f, 0},          /* RIGHT_ARROW */
00188     {0x50, 0},          /* LEFT_ARROW */
00189     {0x51, 0},          /* DOWN_ARROW */
00190     {0x52, 0},          /* UP_ARROW */
00191 };
00192 
00193 #else
00194 /* UK keyboard */
00195 #define KEYMAP_SIZE (152)
00196 const KEYMAP keymap[KEYMAP_SIZE] = {
00197     {0, 0},             /* NUL */
00198     {0, 0},             /* SOH */
00199     {0, 0},             /* STX */
00200     {0, 0},             /* ETX */
00201     {0, 0},             /* EOT */
00202     {0, 0},             /* ENQ */
00203     {0, 0},             /* ACK */
00204     {0, 0},             /* BEL */
00205     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
00206     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
00207     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
00208     {0, 0},             /* VT  */
00209     {0, 0},             /* FF  */
00210     {0, 0},             /* CR  */
00211     {0, 0},             /* SO  */
00212     {0, 0},             /* SI  */
00213     {0, 0},             /* DEL */
00214     {0, 0},             /* DC1 */
00215     {0, 0},             /* DC2 */
00216     {0, 0},             /* DC3 */
00217     {0, 0},             /* DC4 */
00218     {0, 0},             /* NAK */
00219     {0, 0},             /* SYN */
00220     {0, 0},             /* ETB */
00221     {0, 0},             /* CAN */
00222     {0, 0},             /* EM  */
00223     {0, 0},             /* SUB */
00224     {0, 0},             /* ESC */
00225     {0, 0},             /* FS  */
00226     {0, 0},             /* GS  */
00227     {0, 0},             /* RS  */
00228     {0, 0},             /* US  */
00229     {0x2c, 0},          /*   */
00230     {0x1e, KEY_SHIFT},      /* ! */
00231     {0x1f, KEY_SHIFT},      /* " */
00232     {0x32, 0},          /* # */
00233     {0x21, KEY_SHIFT},      /* $ */
00234     {0x22, KEY_SHIFT},      /* % */
00235     {0x24, KEY_SHIFT},      /* & */
00236     {0x34, 0},          /* ' */
00237     {0x26, KEY_SHIFT},      /* ( */
00238     {0x27, KEY_SHIFT},      /* ) */
00239     {0x25, KEY_SHIFT},      /* * */
00240     {0x2e, KEY_SHIFT},      /* + */
00241     {0x36, 0},          /* , */
00242     {0x2d, 0},          /* - */
00243     {0x37, 0},          /* . */
00244     {0x38, 0},          /* / */
00245     {0x27, 0},          /* 0 */
00246     {0x1e, 0},          /* 1 */
00247     {0x1f, 0},          /* 2 */
00248     {0x20, 0},          /* 3 */
00249     {0x21, 0},          /* 4 */
00250     {0x22, 0},          /* 5 */
00251     {0x23, 0},          /* 6 */
00252     {0x24, 0},          /* 7 */
00253     {0x25, 0},          /* 8 */
00254     {0x26, 0},          /* 9 */
00255     {0x33, KEY_SHIFT},      /* : */
00256     {0x33, 0},          /* ; */
00257     {0x36, KEY_SHIFT},      /* < */
00258     {0x2e, 0},          /* = */
00259     {0x37, KEY_SHIFT},      /* > */
00260     {0x38, KEY_SHIFT},      /* ? */
00261     {0x34, KEY_SHIFT},      /* @ */
00262     {0x04, KEY_SHIFT},      /* A */
00263     {0x05, KEY_SHIFT},      /* B */
00264     {0x06, KEY_SHIFT},      /* C */
00265     {0x07, KEY_SHIFT},      /* D */
00266     {0x08, KEY_SHIFT},      /* E */
00267     {0x09, KEY_SHIFT},      /* F */
00268     {0x0a, KEY_SHIFT},      /* G */
00269     {0x0b, KEY_SHIFT},      /* H */
00270     {0x0c, KEY_SHIFT},      /* I */
00271     {0x0d, KEY_SHIFT},      /* J */
00272     {0x0e, KEY_SHIFT},      /* K */
00273     {0x0f, KEY_SHIFT},      /* L */
00274     {0x10, KEY_SHIFT},      /* M */
00275     {0x11, KEY_SHIFT},      /* N */
00276     {0x12, KEY_SHIFT},      /* O */
00277     {0x13, KEY_SHIFT},      /* P */
00278     {0x14, KEY_SHIFT},      /* Q */
00279     {0x15, KEY_SHIFT},      /* R */
00280     {0x16, KEY_SHIFT},      /* S */
00281     {0x17, KEY_SHIFT},      /* T */
00282     {0x18, KEY_SHIFT},      /* U */
00283     {0x19, KEY_SHIFT},      /* V */
00284     {0x1a, KEY_SHIFT},      /* W */
00285     {0x1b, KEY_SHIFT},      /* X */
00286     {0x1c, KEY_SHIFT},      /* Y */
00287     {0x1d, KEY_SHIFT},      /* Z */
00288     {0x2f, 0},          /* [ */
00289     {0x64, 0},          /* \ */
00290     {0x30, 0},          /* ] */
00291     {0x23, KEY_SHIFT},      /* ^ */
00292     {0x2d, KEY_SHIFT},      /* _ */
00293     {0x35, 0},          /* ` */
00294     {0x04, 0},          /* a */
00295     {0x05, 0},          /* b */
00296     {0x06, 0},          /* c */
00297     {0x07, 0},          /* d */
00298     {0x08, 0},          /* e */
00299     {0x09, 0},          /* f */
00300     {0x0a, 0},          /* g */
00301     {0x0b, 0},          /* h */
00302     {0x0c, 0},          /* i */
00303     {0x0d, 0},          /* j */
00304     {0x0e, 0},          /* k */
00305     {0x0f, 0},          /* l */
00306     {0x10, 0},          /* m */
00307     {0x11, 0},          /* n */
00308     {0x12, 0},          /* o */
00309     {0x13, 0},          /* p */
00310     {0x14, 0},          /* q */
00311     {0x15, 0},          /* r */
00312     {0x16, 0},          /* s */
00313     {0x17, 0},          /* t */
00314     {0x18, 0},          /* u */
00315     {0x19, 0},          /* v */
00316     {0x1a, 0},          /* w */
00317     {0x1b, 0},          /* x */
00318     {0x1c, 0},          /* y */
00319     {0x1d, 0},          /* z */
00320     {0x2f, KEY_SHIFT},      /* { */
00321     {0x64, KEY_SHIFT},      /* | */
00322     {0x30, KEY_SHIFT},      /* } */
00323     {0x32, KEY_SHIFT},      /* ~ */
00324     {0, 0},            /* DEL */
00325 
00326     {0x3a, 0},          /* F1 */
00327     {0x3b, 0},          /* F2 */
00328     {0x3c, 0},          /* F3 */
00329     {0x3d, 0},          /* F4 */
00330     {0x3e, 0},          /* F5 */
00331     {0x3f, 0},          /* F6 */
00332     {0x40, 0},          /* F7 */
00333     {0x41, 0},          /* F8 */
00334     {0x42, 0},          /* F9 */
00335     {0x43, 0},          /* F10 */
00336     {0x44, 0},          /* F11 */
00337     {0x45, 0},          /* F12 */
00338 
00339     {0x46, 0},          /* PRINT_SCREEN */
00340     {0x47, 0},          /* SCROLL_LOCK */
00341     {0x39, 0},          /* CAPS_LOCK */
00342     {0x53, 0},          /* NUM_LOCK */
00343     {0x49, 0},          /* INSERT */
00344     {0x4a, 0},          /* HOME */
00345     {0x4b, 0},          /* PAGE_UP */
00346     {0x4e, 0},          /* PAGE_DOWN */
00347 
00348     {0x4f, 0},          /* RIGHT_ARROW */
00349     {0x50, 0},          /* LEFT_ARROW */
00350     {0x51, 0},          /* DOWN_ARROW */
00351     {0x52, 0},          /* UP_ARROW */
00352 };
00353 #endif
00354 
00355 
00356 USBKeyboard::USBKeyboard(bool connect, uint16_t vendor_id, uint16_t product_id, uint16_t product_release):
00357     USBHID(get_usb_phy(), 0, 0, vendor_id, product_id, product_release)
00358 {
00359     _lock_status = 0;
00360     if (connect) {
00361         USBDevice::connect();
00362         wait_ready();
00363     } else {
00364         init();
00365     }
00366 }
00367 
00368 USBKeyboard::USBKeyboard(USBPhy *phy, uint16_t vendor_id, uint16_t product_id, uint16_t product_release):
00369     USBHID(phy, 0, 0, vendor_id, product_id, product_release)
00370 {
00371     _lock_status = 0;
00372 
00373     // User or child responsible for calling connect or init
00374 }
00375 
00376 USBKeyboard::~USBKeyboard()
00377 {
00378     deinit();
00379 }
00380 
00381 const uint8_t *USBKeyboard::report_desc()
00382 {
00383     static const uint8_t reportDescriptor[] = {
00384         USAGE_PAGE(1), 0x01,                    // Generic Desktop
00385         USAGE(1), 0x06,                         // Keyboard
00386         COLLECTION(1), 0x01,                    // Application
00387         REPORT_ID(1),       REPORT_ID_KEYBOARD,
00388 
00389         USAGE_PAGE(1), 0x07,                    // Key Codes
00390         USAGE_MINIMUM(1), 0xE0,
00391         USAGE_MAXIMUM(1), 0xE7,
00392         LOGICAL_MINIMUM(1), 0x00,
00393         LOGICAL_MAXIMUM(1), 0x01,
00394         REPORT_SIZE(1), 0x01,
00395         REPORT_COUNT(1), 0x08,
00396         INPUT(1), 0x02,                         // Data, Variable, Absolute
00397         REPORT_COUNT(1), 0x01,
00398         REPORT_SIZE(1), 0x08,
00399         INPUT(1), 0x01,                         // Constant
00400 
00401 
00402         REPORT_COUNT(1), 0x05,
00403         REPORT_SIZE(1), 0x01,
00404         USAGE_PAGE(1), 0x08,                    // LEDs
00405         USAGE_MINIMUM(1), 0x01,
00406         USAGE_MAXIMUM(1), 0x05,
00407         OUTPUT(1), 0x02,                        // Data, Variable, Absolute
00408         REPORT_COUNT(1), 0x01,
00409         REPORT_SIZE(1), 0x03,
00410         OUTPUT(1), 0x01,                        // Constant
00411 
00412 
00413         REPORT_COUNT(1), 0x06,
00414         REPORT_SIZE(1), 0x08,
00415         LOGICAL_MINIMUM(1), 0x00,
00416         LOGICAL_MAXIMUM(1), 0x65,
00417         USAGE_PAGE(1), 0x07,                    // Key Codes
00418         USAGE_MINIMUM(1), 0x00,
00419         USAGE_MAXIMUM(1), 0x65,
00420         INPUT(1), 0x00,                         // Data, Array
00421         END_COLLECTION(0),
00422 
00423         // Media Control
00424         USAGE_PAGE(1), 0x0C,
00425         USAGE(1), 0x01,
00426         COLLECTION(1), 0x01,
00427         REPORT_ID(1), REPORT_ID_VOLUME,
00428         USAGE_PAGE(1), 0x0C,
00429         LOGICAL_MINIMUM(1), 0x00,
00430         LOGICAL_MAXIMUM(1), 0x01,
00431         REPORT_SIZE(1), 0x01,
00432         REPORT_COUNT(1), 0x07,
00433         USAGE(1), 0xB5,             // Next Track
00434         USAGE(1), 0xB6,             // Previous Track
00435         USAGE(1), 0xB7,             // Stop
00436         USAGE(1), 0xCD,             // Play / Pause
00437         USAGE(1), 0xE2,             // Mute
00438         USAGE(1), 0xE9,             // Volume Up
00439         USAGE(1), 0xEA,             // Volume Down
00440         INPUT(1), 0x02,             // Input (Data, Variable, Absolute)
00441         REPORT_COUNT(1), 0x01,
00442         INPUT(1), 0x01,
00443         END_COLLECTION(0),
00444     };
00445     reportLength = sizeof(reportDescriptor);
00446     return reportDescriptor;
00447 }
00448 
00449 
00450 void USBKeyboard::report_rx()
00451 {
00452     assert_locked();
00453 
00454     HID_REPORT report;
00455     read_nb(&report);
00456 
00457     // we take [1] because [0] is the report ID
00458     _lock_status = report.data[1] & 0x07;
00459 }
00460 
00461 uint8_t USBKeyboard::lock_status()
00462 {
00463     return _lock_status;
00464 }
00465 
00466 int USBKeyboard::_putc(int c)
00467 {
00468     return key_code(c, keymap[c].modifier);
00469 }
00470 
00471 bool USBKeyboard::key_code(uint8_t key, uint8_t modifier)
00472 {
00473     _mutex.lock();
00474 
00475     // Send a simulated keyboard keypress. Returns true if successful.
00476     HID_REPORT report;
00477 
00478     report.data[0] = REPORT_ID_KEYBOARD;
00479     report.data[1] = modifier;
00480     report.data[2] = 0;
00481     report.data[3] = keymap[key].usage;
00482     report.data[4] = 0;
00483     report.data[5] = 0;
00484     report.data[6] = 0;
00485     report.data[7] = 0;
00486     report.data[8] = 0;
00487 
00488     report.length = 9;
00489 
00490     if (!send(&report)) {
00491         _mutex.unlock();
00492         return false;
00493     }
00494 
00495     report.data[1] = 0;
00496     report.data[3] = 0;
00497 
00498     if (!send(&report)) {
00499         _mutex.unlock();
00500         return false;
00501     }
00502 
00503     _mutex.unlock();
00504     return true;
00505 
00506 }
00507 
00508 
00509 bool USBKeyboard::media_control(MEDIA_KEY key)
00510 {
00511     _mutex.lock();
00512 
00513     HID_REPORT report;
00514 
00515     report.data[0] = REPORT_ID_VOLUME;
00516     report.data[1] = (1 << key) & 0x7f;
00517 
00518     report.length = 2;
00519 
00520     if (!send(&report)) {
00521         _mutex.unlock();
00522         return false;
00523     }
00524 
00525     report.data[0] = REPORT_ID_VOLUME;
00526     report.data[1] = 0;
00527 
00528     report.length = 2;
00529 
00530     if (!send(&report)) {
00531         _mutex.unlock();
00532         return false;
00533     }
00534 
00535     _mutex.unlock();
00536     return true;
00537 }
00538 
00539 #define DEFAULT_CONFIGURATION (1)
00540 #define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \
00541                                + (1 * INTERFACE_DESCRIPTOR_LENGTH) \
00542                                + (1 * HID_DESCRIPTOR_LENGTH) \
00543                                + (2 * ENDPOINT_DESCRIPTOR_LENGTH))
00544 
00545 const uint8_t *USBKeyboard::configuration_desc(uint8_t index)
00546 {
00547     if (index != 0) {
00548         return NULL;
00549     }
00550     uint8_t configuration_descriptor_temp[] = {
00551         CONFIGURATION_DESCRIPTOR_LENGTH,    // bLength
00552         CONFIGURATION_DESCRIPTOR,           // bDescriptorType
00553         LSB(TOTAL_DESCRIPTOR_LENGTH),       // wTotalLength (LSB)
00554         MSB(TOTAL_DESCRIPTOR_LENGTH),       // wTotalLength (MSB)
00555         0x01,                               // bNumInterfaces
00556         DEFAULT_CONFIGURATION,              // bConfigurationValue
00557         0x00,                               // iConfiguration
00558         C_RESERVED | C_SELF_POWERED,        // bmAttributes
00559         C_POWER(0),                         // bMaxPower
00560 
00561         INTERFACE_DESCRIPTOR_LENGTH,        // bLength
00562         INTERFACE_DESCRIPTOR,               // bDescriptorType
00563         0x00,                               // bInterfaceNumber
00564         0x00,                               // bAlternateSetting
00565         0x02,                               // bNumEndpoints
00566         HID_CLASS,                          // bInterfaceClass
00567         HID_SUBCLASS_BOOT,                  // bInterfaceSubClass
00568         HID_PROTOCOL_KEYBOARD,              // bInterfaceProtocol
00569         0x00,                               // iInterface
00570 
00571         HID_DESCRIPTOR_LENGTH,              // bLength
00572         HID_DESCRIPTOR,                     // bDescriptorType
00573         LSB(HID_VERSION_1_11),              // bcdHID (LSB)
00574         MSB(HID_VERSION_1_11),              // bcdHID (MSB)
00575         0x00,                               // bCountryCode
00576         0x01,                               // bNumDescriptors
00577         REPORT_DESCRIPTOR,                  // bDescriptorType
00578         (uint8_t)(LSB(report_desc_length())), // wDescriptorLength (LSB)
00579         (uint8_t)(MSB(report_desc_length())), // wDescriptorLength (MSB)
00580 
00581         ENDPOINT_DESCRIPTOR_LENGTH,         // bLength
00582         ENDPOINT_DESCRIPTOR,                // bDescriptorType
00583         _int_in,                            // bEndpointAddress
00584         E_INTERRUPT,                        // bmAttributes
00585         LSB(MAX_HID_REPORT_SIZE),           // wMaxPacketSize (LSB)
00586         MSB(MAX_HID_REPORT_SIZE),           // wMaxPacketSize (MSB)
00587         1,                                  // bInterval (milliseconds)
00588 
00589         ENDPOINT_DESCRIPTOR_LENGTH,         // bLength
00590         ENDPOINT_DESCRIPTOR,                // bDescriptorType
00591         _int_out,                           // bEndpointAddress
00592         E_INTERRUPT,                        // bmAttributes
00593         LSB(MAX_HID_REPORT_SIZE),           // wMaxPacketSize (LSB)
00594         MSB(MAX_HID_REPORT_SIZE),           // wMaxPacketSize (MSB)
00595         1,                                  // bInterval (milliseconds)
00596     };
00597     MBED_ASSERT(sizeof(configuration_descriptor_temp) == sizeof(_configuration_descriptor));
00598     memcpy(_configuration_descriptor, configuration_descriptor_temp, sizeof(_configuration_descriptor));
00599     return _configuration_descriptor;
00600 }
00601 
00602 int USBKeyboard::_getc()
00603 {
00604     return -1;
00605 }