USBMouseKeyboard.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 #include "USBMouseKeyboard.h"
00020 #include "usb_phy_api.h"
00021 #include "ThisThread.h"
00022 
00023 typedef struct {
00024     unsigned char usage;
00025     unsigned char modifier;
00026 } KEYMAP;
00027 
00028 #ifdef US_KEYBOARD
00029 /* US keyboard (as HID standard) */
00030 #define KEYMAP_SIZE (152)
00031 const KEYMAP keymap[KEYMAP_SIZE] = {
00032     {0, 0},             /* NUL */
00033     {0, 0},             /* SOH */
00034     {0, 0},             /* STX */
00035     {0, 0},             /* ETX */
00036     {0, 0},             /* EOT */
00037     {0, 0},             /* ENQ */
00038     {0, 0},             /* ACK */
00039     {0, 0},             /* BEL */
00040     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
00041     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
00042     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
00043     {0, 0},             /* VT  */
00044     {0, 0},             /* FF  */
00045     {0, 0},             /* CR  */
00046     {0, 0},             /* SO  */
00047     {0, 0},             /* SI  */
00048     {0, 0},             /* DEL */
00049     {0, 0},             /* DC1 */
00050     {0, 0},             /* DC2 */
00051     {0, 0},             /* DC3 */
00052     {0, 0},             /* DC4 */
00053     {0, 0},             /* NAK */
00054     {0, 0},             /* SYN */
00055     {0, 0},             /* ETB */
00056     {0, 0},             /* CAN */
00057     {0, 0},             /* EM  */
00058     {0, 0},             /* SUB */
00059     {0, 0},             /* ESC */
00060     {0, 0},             /* FS  */
00061     {0, 0},             /* GS  */
00062     {0, 0},             /* RS  */
00063     {0, 0},             /* US  */
00064     {0x2c, 0},          /*   */
00065     {0x1e, KEY_SHIFT},      /* ! */
00066     {0x34, KEY_SHIFT},      /* " */
00067     {0x20, KEY_SHIFT},      /* # */
00068     {0x21, KEY_SHIFT},      /* $ */
00069     {0x22, KEY_SHIFT},      /* % */
00070     {0x24, KEY_SHIFT},      /* & */
00071     {0x34, 0},          /* ' */
00072     {0x26, KEY_SHIFT},      /* ( */
00073     {0x27, KEY_SHIFT},      /* ) */
00074     {0x25, KEY_SHIFT},      /* * */
00075     {0x2e, KEY_SHIFT},      /* + */
00076     {0x36, 0},          /* , */
00077     {0x2d, 0},          /* - */
00078     {0x37, 0},          /* . */
00079     {0x38, 0},          /* / */
00080     {0x27, 0},          /* 0 */
00081     {0x1e, 0},          /* 1 */
00082     {0x1f, 0},          /* 2 */
00083     {0x20, 0},          /* 3 */
00084     {0x21, 0},          /* 4 */
00085     {0x22, 0},          /* 5 */
00086     {0x23, 0},          /* 6 */
00087     {0x24, 0},          /* 7 */
00088     {0x25, 0},          /* 8 */
00089     {0x26, 0},          /* 9 */
00090     {0x33, KEY_SHIFT},      /* : */
00091     {0x33, 0},          /* ; */
00092     {0x36, KEY_SHIFT},      /* < */
00093     {0x2e, 0},          /* = */
00094     {0x37, KEY_SHIFT},      /* > */
00095     {0x38, KEY_SHIFT},      /* ? */
00096     {0x1f, KEY_SHIFT},      /* @ */
00097     {0x04, KEY_SHIFT},      /* A */
00098     {0x05, KEY_SHIFT},      /* B */
00099     {0x06, KEY_SHIFT},      /* C */
00100     {0x07, KEY_SHIFT},      /* D */
00101     {0x08, KEY_SHIFT},      /* E */
00102     {0x09, KEY_SHIFT},      /* F */
00103     {0x0a, KEY_SHIFT},      /* G */
00104     {0x0b, KEY_SHIFT},      /* H */
00105     {0x0c, KEY_SHIFT},      /* I */
00106     {0x0d, KEY_SHIFT},      /* J */
00107     {0x0e, KEY_SHIFT},      /* K */
00108     {0x0f, KEY_SHIFT},      /* L */
00109     {0x10, KEY_SHIFT},      /* M */
00110     {0x11, KEY_SHIFT},      /* N */
00111     {0x12, KEY_SHIFT},      /* O */
00112     {0x13, KEY_SHIFT},      /* P */
00113     {0x14, KEY_SHIFT},      /* Q */
00114     {0x15, KEY_SHIFT},      /* R */
00115     {0x16, KEY_SHIFT},      /* S */
00116     {0x17, KEY_SHIFT},      /* T */
00117     {0x18, KEY_SHIFT},      /* U */
00118     {0x19, KEY_SHIFT},      /* V */
00119     {0x1a, KEY_SHIFT},      /* W */
00120     {0x1b, KEY_SHIFT},      /* X */
00121     {0x1c, KEY_SHIFT},      /* Y */
00122     {0x1d, KEY_SHIFT},      /* Z */
00123     {0x2f, 0},          /* [ */
00124     {0x31, 0},          /* \ */
00125     {0x30, 0},          /* ] */
00126     {0x23, KEY_SHIFT},      /* ^ */
00127     {0x2d, KEY_SHIFT},      /* _ */
00128     {0x35, 0},          /* ` */
00129     {0x04, 0},          /* a */
00130     {0x05, 0},          /* b */
00131     {0x06, 0},          /* c */
00132     {0x07, 0},          /* d */
00133     {0x08, 0},          /* e */
00134     {0x09, 0},          /* f */
00135     {0x0a, 0},          /* g */
00136     {0x0b, 0},          /* h */
00137     {0x0c, 0},          /* i */
00138     {0x0d, 0},          /* j */
00139     {0x0e, 0},          /* k */
00140     {0x0f, 0},          /* l */
00141     {0x10, 0},          /* m */
00142     {0x11, 0},          /* n */
00143     {0x12, 0},          /* o */
00144     {0x13, 0},          /* p */
00145     {0x14, 0},          /* q */
00146     {0x15, 0},          /* r */
00147     {0x16, 0},          /* s */
00148     {0x17, 0},          /* t */
00149     {0x18, 0},          /* u */
00150     {0x19, 0},          /* v */
00151     {0x1a, 0},          /* w */
00152     {0x1b, 0},          /* x */
00153     {0x1c, 0},          /* y */
00154     {0x1d, 0},          /* z */
00155     {0x2f, KEY_SHIFT},      /* { */
00156     {0x31, KEY_SHIFT},      /* | */
00157     {0x30, KEY_SHIFT},      /* } */
00158     {0x35, KEY_SHIFT},      /* ~ */
00159     {0, 0},             /* DEL */
00160 
00161     {0x3a, 0},          /* F1 */
00162     {0x3b, 0},          /* F2 */
00163     {0x3c, 0},          /* F3 */
00164     {0x3d, 0},          /* F4 */
00165     {0x3e, 0},          /* F5 */
00166     {0x3f, 0},          /* F6 */
00167     {0x40, 0},          /* F7 */
00168     {0x41, 0},          /* F8 */
00169     {0x42, 0},          /* F9 */
00170     {0x43, 0},          /* F10 */
00171     {0x44, 0},          /* F11 */
00172     {0x45, 0},          /* F12 */
00173 
00174     {0x46, 0},          /* PRINT_SCREEN */
00175     {0x47, 0},          /* SCROLL_LOCK */
00176     {0x39, 0},          /* CAPS_LOCK */
00177     {0x53, 0},          /* NUM_LOCK */
00178     {0x49, 0},          /* INSERT */
00179     {0x4a, 0},          /* HOME */
00180     {0x4b, 0},          /* PAGE_UP */
00181     {0x4e, 0},          /* PAGE_DOWN */
00182 
00183     {0x4f, 0},          /* RIGHT_ARROW */
00184     {0x50, 0},          /* LEFT_ARROW */
00185     {0x51, 0},          /* DOWN_ARROW */
00186     {0x52, 0},          /* UP_ARROW */
00187 };
00188 
00189 #else
00190 /* UK keyboard */
00191 #define KEYMAP_SIZE (152)
00192 const KEYMAP keymap[KEYMAP_SIZE] = {
00193     {0, 0},             /* NUL */
00194     {0, 0},             /* SOH */
00195     {0, 0},             /* STX */
00196     {0, 0},             /* ETX */
00197     {0, 0},             /* EOT */
00198     {0, 0},             /* ENQ */
00199     {0, 0},             /* ACK */
00200     {0, 0},             /* BEL */
00201     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
00202     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
00203     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
00204     {0, 0},             /* VT  */
00205     {0, 0},             /* FF  */
00206     {0, 0},             /* CR  */
00207     {0, 0},             /* SO  */
00208     {0, 0},             /* SI  */
00209     {0, 0},             /* DEL */
00210     {0, 0},             /* DC1 */
00211     {0, 0},             /* DC2 */
00212     {0, 0},             /* DC3 */
00213     {0, 0},             /* DC4 */
00214     {0, 0},             /* NAK */
00215     {0, 0},             /* SYN */
00216     {0, 0},             /* ETB */
00217     {0, 0},             /* CAN */
00218     {0, 0},             /* EM  */
00219     {0, 0},             /* SUB */
00220     {0, 0},             /* ESC */
00221     {0, 0},             /* FS  */
00222     {0, 0},             /* GS  */
00223     {0, 0},             /* RS  */
00224     {0, 0},             /* US  */
00225     {0x2c, 0},          /*   */
00226     {0x1e, KEY_SHIFT},      /* ! */
00227     {0x1f, KEY_SHIFT},      /* " */
00228     {0x32, 0},          /* # */
00229     {0x21, KEY_SHIFT},      /* $ */
00230     {0x22, KEY_SHIFT},      /* % */
00231     {0x24, KEY_SHIFT},      /* & */
00232     {0x34, 0},          /* ' */
00233     {0x26, KEY_SHIFT},      /* ( */
00234     {0x27, KEY_SHIFT},      /* ) */
00235     {0x25, KEY_SHIFT},      /* * */
00236     {0x2e, KEY_SHIFT},      /* + */
00237     {0x36, 0},          /* , */
00238     {0x2d, 0},          /* - */
00239     {0x37, 0},          /* . */
00240     {0x38, 0},          /* / */
00241     {0x27, 0},          /* 0 */
00242     {0x1e, 0},          /* 1 */
00243     {0x1f, 0},          /* 2 */
00244     {0x20, 0},          /* 3 */
00245     {0x21, 0},          /* 4 */
00246     {0x22, 0},          /* 5 */
00247     {0x23, 0},          /* 6 */
00248     {0x24, 0},          /* 7 */
00249     {0x25, 0},          /* 8 */
00250     {0x26, 0},          /* 9 */
00251     {0x33, KEY_SHIFT},      /* : */
00252     {0x33, 0},          /* ; */
00253     {0x36, KEY_SHIFT},      /* < */
00254     {0x2e, 0},          /* = */
00255     {0x37, KEY_SHIFT},      /* > */
00256     {0x38, KEY_SHIFT},      /* ? */
00257     {0x34, KEY_SHIFT},      /* @ */
00258     {0x04, KEY_SHIFT},      /* A */
00259     {0x05, KEY_SHIFT},      /* B */
00260     {0x06, KEY_SHIFT},      /* C */
00261     {0x07, KEY_SHIFT},      /* D */
00262     {0x08, KEY_SHIFT},      /* E */
00263     {0x09, KEY_SHIFT},      /* F */
00264     {0x0a, KEY_SHIFT},      /* G */
00265     {0x0b, KEY_SHIFT},      /* H */
00266     {0x0c, KEY_SHIFT},      /* I */
00267     {0x0d, KEY_SHIFT},      /* J */
00268     {0x0e, KEY_SHIFT},      /* K */
00269     {0x0f, KEY_SHIFT},      /* L */
00270     {0x10, KEY_SHIFT},      /* M */
00271     {0x11, KEY_SHIFT},      /* N */
00272     {0x12, KEY_SHIFT},      /* O */
00273     {0x13, KEY_SHIFT},      /* P */
00274     {0x14, KEY_SHIFT},      /* Q */
00275     {0x15, KEY_SHIFT},      /* R */
00276     {0x16, KEY_SHIFT},      /* S */
00277     {0x17, KEY_SHIFT},      /* T */
00278     {0x18, KEY_SHIFT},      /* U */
00279     {0x19, KEY_SHIFT},      /* V */
00280     {0x1a, KEY_SHIFT},      /* W */
00281     {0x1b, KEY_SHIFT},      /* X */
00282     {0x1c, KEY_SHIFT},      /* Y */
00283     {0x1d, KEY_SHIFT},      /* Z */
00284     {0x2f, 0},          /* [ */
00285     {0x64, 0},          /* \ */
00286     {0x30, 0},          /* ] */
00287     {0x23, KEY_SHIFT},      /* ^ */
00288     {0x2d, KEY_SHIFT},      /* _ */
00289     {0x35, 0},          /* ` */
00290     {0x04, 0},          /* a */
00291     {0x05, 0},          /* b */
00292     {0x06, 0},          /* c */
00293     {0x07, 0},          /* d */
00294     {0x08, 0},          /* e */
00295     {0x09, 0},          /* f */
00296     {0x0a, 0},          /* g */
00297     {0x0b, 0},          /* h */
00298     {0x0c, 0},          /* i */
00299     {0x0d, 0},          /* j */
00300     {0x0e, 0},          /* k */
00301     {0x0f, 0},          /* l */
00302     {0x10, 0},          /* m */
00303     {0x11, 0},          /* n */
00304     {0x12, 0},          /* o */
00305     {0x13, 0},          /* p */
00306     {0x14, 0},          /* q */
00307     {0x15, 0},          /* r */
00308     {0x16, 0},          /* s */
00309     {0x17, 0},          /* t */
00310     {0x18, 0},          /* u */
00311     {0x19, 0},          /* v */
00312     {0x1a, 0},          /* w */
00313     {0x1b, 0},          /* x */
00314     {0x1c, 0},          /* y */
00315     {0x1d, 0},          /* z */
00316     {0x2f, KEY_SHIFT},      /* { */
00317     {0x64, KEY_SHIFT},      /* | */
00318     {0x30, KEY_SHIFT},      /* } */
00319     {0x32, KEY_SHIFT},      /* ~ */
00320     {0, 0},            /* DEL */
00321 
00322     {0x3a, 0},          /* F1 */
00323     {0x3b, 0},          /* F2 */
00324     {0x3c, 0},          /* F3 */
00325     {0x3d, 0},          /* F4 */
00326     {0x3e, 0},          /* F5 */
00327     {0x3f, 0},          /* F6 */
00328     {0x40, 0},          /* F7 */
00329     {0x41, 0},          /* F8 */
00330     {0x42, 0},          /* F9 */
00331     {0x43, 0},          /* F10 */
00332     {0x44, 0},          /* F11 */
00333     {0x45, 0},          /* F12 */
00334 
00335     {0x46, 0},          /* PRINT_SCREEN */
00336     {0x47, 0},          /* SCROLL_LOCK */
00337     {0x39, 0},          /* CAPS_LOCK */
00338     {0x53, 0},          /* NUM_LOCK */
00339     {0x49, 0},          /* INSERT */
00340     {0x4a, 0},          /* HOME */
00341     {0x4b, 0},          /* PAGE_UP */
00342     {0x4e, 0},          /* PAGE_DOWN */
00343 
00344     {0x4f, 0},          /* RIGHT_ARROW */
00345     {0x50, 0},          /* LEFT_ARROW */
00346     {0x51, 0},          /* DOWN_ARROW */
00347     {0x52, 0},          /* UP_ARROW */
00348 };
00349 #endif
00350 
00351 USBMouseKeyboard::USBMouseKeyboard(bool connect_blocking, MOUSE_TYPE mouse_type, uint16_t vendor_id, uint16_t product_id, uint16_t product_release):
00352     USBHID(get_usb_phy(), 0, 0, vendor_id, product_id, product_release)
00353 {
00354     _lock_status = 0;
00355     _button = 0;
00356     _mouse_type = mouse_type;
00357 
00358     if (connect_blocking) {
00359         USBDevice::connect();
00360         wait_ready();
00361     } else {
00362         init();
00363     }
00364 };
00365 
00366 USBMouseKeyboard::USBMouseKeyboard(USBPhy *phy, MOUSE_TYPE mouse_type, uint16_t vendor_id, uint16_t product_id, uint16_t product_release):
00367     USBHID(phy, 0, 0, vendor_id, product_id, product_release)
00368 {
00369     _lock_status = 0;
00370     _button = 0;
00371     _mouse_type = mouse_type;
00372 };
00373 
00374 /**
00375  * Destroy this object
00376  *
00377  * Any classes which inherit from this class must call deinit
00378  * before this destructor runs.
00379  */
00380 USBMouseKeyboard::~USBMouseKeyboard()
00381 {
00382     deinit();
00383 }
00384 
00385 const uint8_t *USBMouseKeyboard::report_desc()
00386 {
00387     if (_mouse_type == REL_MOUSE) {
00388         static const uint8_t reportDescriptor[] = {
00389             // Keyboard
00390             USAGE_PAGE(1),      0x01,
00391             USAGE(1),           0x06,
00392             COLLECTION(1),      0x01,
00393             REPORT_ID(1),       REPORT_ID_KEYBOARD,
00394             USAGE_PAGE(1),      0x07,
00395             USAGE_MINIMUM(1),       0xE0,
00396             USAGE_MAXIMUM(1),       0xE7,
00397             LOGICAL_MINIMUM(1),     0x00,
00398             LOGICAL_MAXIMUM(1),     0x01,
00399             REPORT_SIZE(1),     0x01,
00400             REPORT_COUNT(1),    0x08,
00401             INPUT(1),           0x02,
00402             REPORT_COUNT(1),    0x01,
00403             REPORT_SIZE(1),     0x08,
00404             INPUT(1),           0x01,
00405             REPORT_COUNT(1),    0x05,
00406             REPORT_SIZE(1),     0x01,
00407             USAGE_PAGE(1),      0x08,
00408             USAGE_MINIMUM(1),       0x01,
00409             USAGE_MAXIMUM(1),       0x05,
00410             OUTPUT(1),          0x02,
00411             REPORT_COUNT(1),    0x01,
00412             REPORT_SIZE(1),     0x03,
00413             OUTPUT(1),          0x01,
00414             REPORT_COUNT(1),    0x06,
00415             REPORT_SIZE(1),     0x08,
00416             LOGICAL_MINIMUM(1),     0x00,
00417             LOGICAL_MAXIMUM(2),     0xff, 0x00,
00418             USAGE_PAGE(1),      0x07,
00419             USAGE_MINIMUM(1),       0x00,
00420             USAGE_MAXIMUM(2),       0xff, 0x00,
00421             INPUT(1),           0x00,
00422             END_COLLECTION(0),
00423 
00424             // Mouse
00425             USAGE_PAGE(1),      0x01,           // Generic Desktop
00426             USAGE(1),           0x02,           // Mouse
00427             COLLECTION(1),      0x01,           // Application
00428             USAGE(1),           0x01,           // Pointer
00429             COLLECTION(1),      0x00,           // Physical
00430             REPORT_ID(1),       REPORT_ID_MOUSE,
00431             REPORT_COUNT(1),    0x03,
00432             REPORT_SIZE(1),     0x01,
00433             USAGE_PAGE(1),      0x09,           // Buttons
00434             USAGE_MINIMUM(1),       0x1,
00435             USAGE_MAXIMUM(1),       0x3,
00436             LOGICAL_MINIMUM(1),     0x00,
00437             LOGICAL_MAXIMUM(1),     0x01,
00438             INPUT(1),           0x02,
00439             REPORT_COUNT(1),    0x01,
00440             REPORT_SIZE(1),     0x05,
00441             INPUT(1),           0x01,
00442             REPORT_COUNT(1),    0x03,
00443             REPORT_SIZE(1),     0x08,
00444             USAGE_PAGE(1),      0x01,
00445             USAGE(1),           0x30,           // X
00446             USAGE(1),           0x31,           // Y
00447             USAGE(1),           0x38,           // scroll
00448             LOGICAL_MINIMUM(1),     0x81,
00449             LOGICAL_MAXIMUM(1),     0x7f,
00450             INPUT(1),           0x06,
00451             END_COLLECTION(0),
00452             END_COLLECTION(0),
00453 
00454 
00455             // Media Control
00456             USAGE_PAGE(1), 0x0C,
00457             USAGE(1), 0x01,
00458             COLLECTION(1), 0x01,
00459             REPORT_ID(1), REPORT_ID_VOLUME,
00460             USAGE_PAGE(1), 0x0C,
00461             LOGICAL_MINIMUM(1), 0x00,
00462             LOGICAL_MAXIMUM(1), 0x01,
00463             REPORT_SIZE(1), 0x01,
00464             REPORT_COUNT(1), 0x07,
00465             USAGE(1), 0xB5,             // Next Track
00466             USAGE(1), 0xB6,             // Previous Track
00467             USAGE(1), 0xB7,             // Stop
00468             USAGE(1), 0xCD,             // Play / Pause
00469             USAGE(1), 0xE2,             // Mute
00470             USAGE(1), 0xE9,             // Volume Up
00471             USAGE(1), 0xEA,             // Volume Down
00472             INPUT(1), 0x02,             // Input (Data, Variable, Absolute)
00473             REPORT_COUNT(1), 0x01,
00474             INPUT(1), 0x01,
00475             END_COLLECTION(0),
00476         };
00477         reportLength = sizeof(reportDescriptor);
00478         return reportDescriptor;
00479     } else if (_mouse_type == ABS_MOUSE) {
00480         static const uint8_t reportDescriptor[] = {
00481 
00482             // Keyboard
00483             USAGE_PAGE(1),      0x01,
00484             USAGE(1),           0x06,
00485             COLLECTION(1),      0x01,
00486             REPORT_ID(1),       REPORT_ID_KEYBOARD,
00487             USAGE_PAGE(1),      0x07,
00488             USAGE_MINIMUM(1),       0xE0,
00489             USAGE_MAXIMUM(1),       0xE7,
00490             LOGICAL_MINIMUM(1),     0x00,
00491             LOGICAL_MAXIMUM(1),     0x01,
00492             REPORT_SIZE(1),     0x01,
00493             REPORT_COUNT(1),    0x08,
00494             INPUT(1),           0x02,
00495             REPORT_COUNT(1),    0x01,
00496             REPORT_SIZE(1),     0x08,
00497             INPUT(1),           0x01,
00498             REPORT_COUNT(1),    0x05,
00499             REPORT_SIZE(1),     0x01,
00500             USAGE_PAGE(1),      0x08,
00501             USAGE_MINIMUM(1),       0x01,
00502             USAGE_MAXIMUM(1),       0x05,
00503             OUTPUT(1),          0x02,
00504             REPORT_COUNT(1),    0x01,
00505             REPORT_SIZE(1),     0x03,
00506             OUTPUT(1),          0x01,
00507             REPORT_COUNT(1),    0x06,
00508             REPORT_SIZE(1),     0x08,
00509             LOGICAL_MINIMUM(1),     0x00,
00510             LOGICAL_MAXIMUM(2),     0xff, 0x00,
00511             USAGE_PAGE(1),      0x07,
00512             USAGE_MINIMUM(1),       0x00,
00513             USAGE_MAXIMUM(2),       0xff, 0x00,
00514             INPUT(1),           0x00,
00515             END_COLLECTION(0),
00516 
00517             // Mouse
00518             USAGE_PAGE(1), 0x01,               // Generic Desktop
00519             USAGE(1), 0x02,                    // Mouse
00520             COLLECTION(1), 0x01,               // Application
00521             USAGE(1), 0x01,                    // Pointer
00522             COLLECTION(1), 0x00,               // Physical
00523             REPORT_ID(1),       REPORT_ID_MOUSE,
00524 
00525             USAGE_PAGE(1), 0x01,                // Generic Desktop
00526             USAGE(1), 0x30,                     // X
00527             USAGE(1), 0x31,                     // Y
00528             LOGICAL_MINIMUM(1), 0x00,           // 0
00529             LOGICAL_MAXIMUM(2), 0xff, 0x7f,     // 32767
00530             REPORT_SIZE(1), 0x10,
00531             REPORT_COUNT(1), 0x02,
00532             INPUT(1), 0x02,                     // Data, Variable, Absolute
00533 
00534             USAGE_PAGE(1), 0x01,                // Generic Desktop
00535             USAGE(1), 0x38,                     // scroll
00536             LOGICAL_MINIMUM(1), 0x81,           // -127
00537             LOGICAL_MAXIMUM(1), 0x7f,           // 127
00538             REPORT_SIZE(1), 0x08,
00539             REPORT_COUNT(1), 0x01,
00540             INPUT(1), 0x06,                     // Data, Variable, Relative
00541 
00542             USAGE_PAGE(1), 0x09,                // Buttons
00543             USAGE_MINIMUM(1), 0x01,
00544             USAGE_MAXIMUM(1), 0x03,
00545             LOGICAL_MINIMUM(1), 0x00,           // 0
00546             LOGICAL_MAXIMUM(1), 0x01,           // 1
00547             REPORT_COUNT(1), 0x03,
00548             REPORT_SIZE(1), 0x01,
00549             INPUT(1), 0x02,                     // Data, Variable, Absolute
00550             REPORT_COUNT(1), 0x01,
00551             REPORT_SIZE(1), 0x05,
00552             INPUT(1), 0x01,                     // Constant
00553 
00554             END_COLLECTION(0),
00555             END_COLLECTION(0),
00556 
00557             // Media Control
00558             USAGE_PAGE(1), 0x0C,
00559             USAGE(1), 0x01,
00560             COLLECTION(1), 0x01,
00561             REPORT_ID(1), REPORT_ID_VOLUME,
00562             USAGE_PAGE(1), 0x0C,
00563             LOGICAL_MINIMUM(1), 0x00,
00564             LOGICAL_MAXIMUM(1), 0x01,
00565             REPORT_SIZE(1), 0x01,
00566             REPORT_COUNT(1), 0x07,
00567             USAGE(1), 0xB5,             // Next Track
00568             USAGE(1), 0xB6,             // Previous Track
00569             USAGE(1), 0xB7,             // Stop
00570             USAGE(1), 0xCD,             // Play / Pause
00571             USAGE(1), 0xE2,             // Mute
00572             USAGE(1), 0xE9,             // Volume Up
00573             USAGE(1), 0xEA,             // Volume Down
00574             INPUT(1), 0x02,             // Input (Data, Variable, Absolute)
00575             REPORT_COUNT(1), 0x01,
00576             INPUT(1), 0x01,
00577             END_COLLECTION(0),
00578         };
00579         reportLength = sizeof(reportDescriptor);
00580         return reportDescriptor;
00581     }
00582 
00583     return NULL;
00584 }
00585 
00586 void USBMouseKeyboard::report_rx()
00587 {
00588     assert_locked();
00589 
00590     HID_REPORT report;
00591     read_nb(&report);
00592 
00593     // we take [1] because [0] is the report ID
00594     _lock_status = report.data[1] & 0x07;
00595 }
00596 
00597 uint8_t USBMouseKeyboard::lock_status()
00598 {
00599     return _lock_status;
00600 }
00601 
00602 bool USBMouseKeyboard::update(int16_t x, int16_t y, uint8_t button, int8_t z)
00603 {
00604     bool ret;
00605     switch (_mouse_type) {
00606         case REL_MOUSE:
00607             _mutex.lock();
00608 
00609             while (x > 127) {
00610                 if (!_mouse_send(127, 0, button, z)) {
00611                     _mutex.unlock();
00612                     return false;
00613                 }
00614                 x = x - 127;
00615             }
00616             while (x < -128) {
00617                 if (!_mouse_send(-128, 0, button, z)) {
00618                     _mutex.unlock();
00619                     return false;
00620                 }
00621                 x = x + 128;
00622             }
00623             while (y > 127) {
00624                 if (!_mouse_send(0, 127, button, z)) {
00625                     _mutex.unlock();
00626                     return false;
00627                 }
00628                 y = y - 127;
00629             }
00630             while (y < -128) {
00631                 if (!_mouse_send(0, -128, button, z)) {
00632                     _mutex.unlock();
00633                     return false;
00634                 }
00635                 y = y + 128;
00636             }
00637             ret = _mouse_send(x, y, button, z);
00638 
00639             _mutex.unlock();
00640             return ret;
00641         case ABS_MOUSE:
00642             _mutex.lock();
00643 
00644             HID_REPORT report;
00645 
00646             report.data[0] = REPORT_ID_MOUSE;
00647             report.data[1] = x & 0xff;
00648             report.data[2] = (x >> 8) & 0xff;
00649             report.data[3] = y & 0xff;
00650             report.data[4] = (y >> 8) & 0xff;
00651             report.data[5] = -z;
00652             report.data[6] = button & 0x07;
00653 
00654             report.length = 7;
00655 
00656             ret = send(&report);
00657 
00658             _mutex.unlock();
00659             return ret;
00660         default:
00661             return false;
00662     }
00663 }
00664 
00665 bool USBMouseKeyboard::_mouse_send(int8_t x, int8_t y, uint8_t buttons, int8_t z)
00666 {
00667     _mutex.lock();
00668 
00669     HID_REPORT report;
00670     report.data[0] = REPORT_ID_MOUSE;
00671     report.data[1] = buttons & 0x07;
00672     report.data[2] = x;
00673     report.data[3] = y;
00674     report.data[4] = -z; // >0 to scroll down, <0 to scroll up
00675 
00676     report.length = 5;
00677 
00678     bool ret = send(&report);
00679 
00680     _mutex.unlock();
00681     return ret;
00682 }
00683 
00684 bool USBMouseKeyboard::move(int16_t x, int16_t y)
00685 {
00686     _mutex.lock();
00687 
00688     bool ret = update(x, y, _button, 0);
00689 
00690     _mutex.unlock();
00691     return ret;
00692 }
00693 
00694 bool USBMouseKeyboard::scroll(int8_t z)
00695 {
00696     _mutex.lock();
00697 
00698     bool ret = update(0, 0, _button, z);
00699 
00700     _mutex.unlock();
00701     return ret;
00702 }
00703 
00704 bool USBMouseKeyboard::doubleClick()
00705 {
00706     _mutex.lock();
00707 
00708     if (!click(MOUSE_LEFT)) {
00709         _mutex.unlock();
00710         return false;
00711     }
00712     rtos::ThisThread::sleep_for(100);
00713     bool ret = click(MOUSE_LEFT);
00714 
00715     _mutex.unlock();
00716     return ret;
00717 }
00718 
00719 bool USBMouseKeyboard::click(uint8_t button)
00720 {
00721     _mutex.lock();
00722 
00723     if (!update(0, 0, button, 0)) {
00724         _mutex.unlock();
00725         return false;
00726     }
00727     rtos::ThisThread::sleep_for(10);
00728     bool ret = update(0, 0, 0, 0);
00729 
00730     _mutex.unlock();
00731     return ret;
00732 }
00733 
00734 bool USBMouseKeyboard::press(uint8_t button)
00735 {
00736     _mutex.lock();
00737 
00738     _button = button & 0x07;
00739     bool ret = update(0, 0, button, 0);
00740 
00741     _mutex.unlock();
00742     return ret;
00743 }
00744 
00745 bool USBMouseKeyboard::release(uint8_t button)
00746 {
00747     _mutex.lock();
00748 
00749     _button = (_button & (~button)) & 0x07;
00750     bool ret = update(0, 0, _button, 0);
00751 
00752     _mutex.unlock();
00753     return ret;
00754 }
00755 
00756 int USBMouseKeyboard::_putc(int c)
00757 {
00758     _mutex.lock();
00759 
00760     bool ret = key_code(c, keymap[c].modifier);
00761 
00762     _mutex.unlock();
00763     return ret;
00764 }
00765 
00766 bool USBMouseKeyboard::key_code(uint8_t key, uint8_t modifier)
00767 {
00768     // Send a simulated keyboard keypress. Returns true if successful.
00769     _mutex.lock();
00770 
00771     HID_REPORT report;
00772 
00773     report.data[0] = REPORT_ID_KEYBOARD;
00774     report.data[1] = modifier;
00775     report.data[2] = 0;
00776     report.data[3] = keymap[key].usage;
00777     report.data[4] = 0;
00778     report.data[5] = 0;
00779     report.data[6] = 0;
00780     report.data[7] = 0;
00781     report.data[8] = 0;
00782 
00783     report.length = 9;
00784 
00785     if (!send(&report)) {
00786         _mutex.unlock();
00787         return false;
00788     }
00789 
00790     report.data[1] = 0;
00791     report.data[3] = 0;
00792 
00793     if (!send(&report)) {
00794         _mutex.unlock();
00795         return false;
00796     }
00797 
00798     _mutex.unlock();
00799     return true;
00800 }
00801 
00802 
00803 bool USBMouseKeyboard::media_control(MEDIA_KEY key)
00804 {
00805     _mutex.lock();
00806 
00807     HID_REPORT report;
00808 
00809     report.data[0] = REPORT_ID_VOLUME;
00810     report.data[1] = (1 << key) & 0x7f;
00811 
00812     report.length = 2;
00813 
00814     send(&report);
00815 
00816     report.data[0] = REPORT_ID_VOLUME;
00817     report.data[1] = 0;
00818 
00819     report.length = 2;
00820 
00821     bool ret = send(&report);
00822 
00823     _mutex.unlock();
00824     return ret;
00825 }
00826 
00827 int USBMouseKeyboard::_getc()
00828 {
00829     return -1;
00830 }