firmware/usbstack/usb_hid.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2009 by Tomer Shalev
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "string.h"
  22 #include "system.h"
  23 #include "usb_core.h"
  24 #include "usb_drv.h"
  25 #include "kernel.h"
  26 #include "usb_hid.h"
  27 #include "usb_class_driver.h"
  28 /*#define LOGF_ENABLE*/
  29 #include "logf.h"
  30
  31 /* Documents avaiable here: http://www.usb.org/developers/devclass_docs/ */
  32
  33 #define HID_VER                         0x0110 /* 1.1 */
  34 /* Subclass Codes (HID1_11.pdf, page 18) */
  35 #define SUBCLASS_NONE                   0
  36 #define SUBCLASS_BOOT_INTERFACE         1
  37 /* Protocol Codes (HID1_11.pdf, page 19) */
  38 #define PROTOCOL_CODE_NONE              0
  39 #define PROTOCOL_CODE_KEYBOARD          1
  40 #define PROTOCOL_CODE_MOUSE             2
  41 /* HID main items (HID1_11.pdf, page 38) */
  42 #define INPUT                           0x80
  43 #define OUTPUT                          0x90
  44 #define COLLECTION                      0xA0
  45 #define COLLECTION_PHYSICAL             0x00
  46 #define COLLECTION_APPLICATION          0x01
  47 #define END_COLLECTION                  0xC0
  48 /* Parts (HID1_11.pdf, page 40) */
  49 #define MAIN_ITEM_CONSTANT              BIT_N(0) /* 0x01 */
  50 #define MAIN_ITEM_VARIABLE              BIT_N(1) /* 0x02 */
  51 #define MAIN_ITEM_RELATIVE              BIT_N(2) /* 0x04 */
  52 #define MAIN_ITEM_WRAP                  BIT_N(3) /* 0x08 */
  53 #define MAIN_ITEM_NONLINEAR             BIT_N(4) /* 0x10 */
  54 #define MAIN_ITEM_NO_PREFERRED          BIT_N(5) /* 0x20 */
  55 #define MAIN_ITEM_NULL_STATE            BIT_N(6) /* 0x40 */
  56 #define MAIN_ITEM_VOLATILE              BIT_N(7) /* 0x80 */
  57 #define MAIN_ITEM_BUFFERED_BYTES        BIT_N(8) /* 0x0100 */
  58 /* HID global items (HID1_11.pdf, page 45) */
  59 #define USAGE_PAGE                      0x04
  60 #define LOGICAL_MINIMUM                 0x14
  61 #define LOGICAL_MAXIMUM                 0x24
  62 #define REPORT_SIZE                     0x74
  63 #define REPORT_ID                       0x84
  64 #define REPORT_COUNT                    0x94
  65 /* HID local items (HID1_11.pdf, page 50) */
  66 #define USAGE_MINIMUM                   0x18
  67 #define USAGE_MAXIMUM                   0x28
  68 /* Types of class descriptors (HID1_11.pdf, page 59) */
  69 #define USB_DT_HID                      0x21
  70 #define USB_DT_REPORT                   0x22
  71
  72 #define CONSUMER_USAGE                  0x09
  73
  74 /* HID-only class specific requests (HID1_11.pdf, page 61) */
  75 #define USB_HID_GET_REPORT              0x01
  76 #define USB_HID_GET_IDLE                0x02
  77 #define USB_HID_GET_PROTOCOL            0x03
  78 #define USB_HID_SET_REPORT              0x09
  79 #define USB_HID_SET_IDLE                0x0A
  80 #define USB_HID_SET_PROTOCOL            0x0B
  81
  82 /* Get_Report and Set_Report Report Type field (HID1_11.pdf, page 61) */
  83 #define REPORT_TYPE_INPUT               0x01
  84 #define REPORT_TYPE_OUTPUT              0x02
  85 #define REPORT_TYPE_FEATURE             0x03
  86
  87 #define HID_BUF_SIZE_MSG                16
  88 #define HID_BUF_SIZE_CMD                16
  89 #define HID_BUF_SIZE_REPORT             160
  90 #define HID_NUM_BUFFERS                 5
  91 #define SET_REPORT_BUF_LEN 2
  92
  93 #ifdef LOGF_ENABLE
  94
  95 #define BUF_DUMP_BUF_LEN       HID_BUF_SIZE_REPORT
  96 #define BUF_DUMP_PREFIX_SIZE   5
  97 #define BUF_DUMP_ITEMS_IN_LINE 8
  98 #define BUF_DUMP_LINE_SIZE     (BUF_DUMP_ITEMS_IN_LINE * 3)
  99 #define BUF_DUMP_NUM_LINES     (BUF_DUMP_BUF_LEN / BUF_DUMP_ITEMS_IN_LINE)
 100 #endif
 101
 102 #define HID_BUF_INC(i) do { (i) = ((i) + 1) % HID_NUM_BUFFERS; } while (0)
 103 #define PACK_VAL(dest, val) *(dest)++ = (val) & 0xff
 104
 105 typedef enum
 106 {
 107     REPORT_ID_KEYBOARD = 1,
 108     REPORT_ID_CONSUMER,
 109 #ifdef HAVE_USB_HID_MOUSE
 110     REPORT_ID_MOUSE,
 111 #endif
 112     REPORT_ID_COUNT,
 113 } report_id_t;
 114
 115 /* hid interface */
 116 static struct usb_interface_descriptor __attribute__((aligned(2)))
 117                                 interface_descriptor =
 118 {
 119     .bLength            = sizeof(struct usb_interface_descriptor),
 120     .bDescriptorType    = USB_DT_INTERFACE,
 121     .bInterfaceNumber   = 0,
 122     .bAlternateSetting  = 0,
 123     .bNumEndpoints      = 1,
 124     .bInterfaceClass    = USB_CLASS_HID,
 125     .bInterfaceSubClass = SUBCLASS_BOOT_INTERFACE,
 126     .bInterfaceProtocol = PROTOCOL_CODE_KEYBOARD,
 127     .iInterface         = 0
 128 };
 129
 130 struct usb_hid_descriptor {
 131     uint8_t  bLength;
 132     uint8_t  bDescriptorType;
 133     uint16_t wBcdHID;
 134     uint8_t  bCountryCode;
 135     uint8_t  bNumDescriptors;
 136     uint8_t  bDescriptorType0;
 137     uint16_t wDescriptorLength0;
 138 } __attribute__ ((packed));
 139
 140 static struct usb_hid_descriptor __attribute__((aligned(2))) hid_descriptor =
 141 {
 142     .bLength            = sizeof(struct usb_hid_descriptor),
 143     .bDescriptorType    = USB_DT_HID,
 144     .wBcdHID            = HID_VER,
 145     .bCountryCode       = 0,
 146     .bNumDescriptors    = 1,
 147     .bDescriptorType0   = USB_DT_REPORT,
 148     .wDescriptorLength0 = 0
 149 };
 150
 151 static struct usb_endpoint_descriptor __attribute__((aligned(2)))
 152     endpoint_descriptor =
 153 {
 154     .bLength          = sizeof(struct usb_endpoint_descriptor),
 155     .bDescriptorType  = USB_DT_ENDPOINT,
 156     .bEndpointAddress = 0,
 157     .bmAttributes     = USB_ENDPOINT_XFER_INT,
 158     .wMaxPacketSize   = 0,
 159     .bInterval        = 0
 160 };
 161
 162 typedef struct
 163 {
 164     uint8_t usage_page;
 165     /* Write the id into the buffer in the appropriate location, and returns the
 166      * buffer length */
 167     uint8_t (*buf_set)(unsigned char *buf, int id);
 168     bool is_key_released;
 169 } usb_hid_report_t;
 170
 171 static usb_hid_report_t usb_hid_reports[REPORT_ID_COUNT];
 172
 173 static unsigned char report_descriptor[HID_BUF_SIZE_REPORT]
 174     USB_DEVBSS_ATTR __attribute__((aligned(32)));
 175
 176 static unsigned char send_buffer[HID_NUM_BUFFERS][HID_BUF_SIZE_MSG]
 177     USB_DEVBSS_ATTR __attribute__((aligned(32)));
 178 static size_t send_buffer_len[HID_NUM_BUFFERS];
 179 static int cur_buf_prepare;
 180 static int cur_buf_send;
 181
 182 static bool active = false;
 183 static bool currently_sending = false;
 184 static int ep_in;
 185 static int usb_interface;
 186
 187 static void usb_hid_try_send_drv(void);
 188
 189 static void pack_parameter(unsigned char **dest, bool is_signed, bool mark_size,
 190         uint8_t parameter, uint32_t value)
 191 {
 192     uint8_t size_value = 1; /* # of bytes */
 193     uint32_t v = value;
 194
 195     while (v >>= 8)
 196         size_value++;
 197
 198     if (is_signed)
 199     {
 200         bool is_negative = 0;
 201
 202         switch (size_value)
 203         {
 204             case 1:
 205                 is_negative = (int8_t)value < 0;
 206                 break;
 207             case 2:
 208                 is_negative = (int16_t)value < 0;
 209                 break;
 210             case 3:
 211             case 4:
 212                 is_negative = (int32_t)value < 0;
 213                 break;
 214             default:
 215                 break;
 216         }
 217
 218         if (is_negative)
 219             size_value++;
 220     }
 221
 222     **dest = parameter | (mark_size ? size_value : 0);
 223     (*dest)++;
 224
 225     while (size_value--)
 226     {
 227         **dest = value & 0xff;
 228         (*dest)++;
 229         value >>= 8;
 230     }
 231 }
 232
 233 int usb_hid_request_endpoints(struct usb_class_driver *drv)
 234 {
 235     ep_in = usb_core_request_endpoint(USB_ENDPOINT_XFER_INT, USB_DIR_IN, drv);
 236     if (ep_in < 0)
 237         return -1;
 238
 239     return 0;
 240 }
 241
 242 int usb_hid_set_first_interface(int interface)
 243 {
 244     usb_interface = interface;
 245
 246     return interface + 1;
 247 }
 248
 249 #ifdef LOGF_ENABLE
 250 static unsigned char buf_dump_ar[BUF_DUMP_NUM_LINES][BUF_DUMP_LINE_SIZE + 1]
 251     USB_DEVBSS_ATTR __attribute__((aligned(32)));
 252
 253 void buf_dump(unsigned char *buf, size_t size, char *msg)
 254 {
 255     size_t i;
 256     int line;
 257     static const char v[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 258         'A', 'B', 'C', 'D', 'E', 'F' };
 259
 260     for (i = 0, line = 0; i < size; line++)
 261     {
 262         int j, i0 = i;
 263         char *b = buf_dump_ar[line];
 264
 265         for (j = 0; j < BUF_DUMP_ITEMS_IN_LINE && i < size; j++, i++)
 266         {
 267             *b++ = v[buf[i] >> 4];
 268             *b++ = v[buf[i] & 0xF];
 269             *b++ = ' ';
 270         }
 271         *b = 0;
 272
 273         /* Prefix must be of len BUF_DUMP_PREFIX_SIZE */
 274         logf("%03d: %s %s", i0, buf_dump_ar[line], msg);
 275     }
 276 }
 277 #else
 278 #undef buf_dump
 279 #define buf_dump(...)
 280 #endif
 281
 282 #define BUF_LEN_KEYBOARD 7
 283 static uint8_t buf_set_keyboard(unsigned char *buf, int id)
 284 {
 285     memset(buf, 0, BUF_LEN_KEYBOARD);
 286     int key, i = 1;
 287
 288     /* Each key is a word in id (up to 4 keys supported) */
 289     while ((key = id & 0xff))
 290     {
 291         /* Each modifier key is a bit in the first byte */
 292         if (HID_KEYBOARD_LEFT_CONTROL <= key && key <= HID_KEYBOARD_RIGHT_GUI)
 293             buf[0] |= (1 << (key - HID_KEYBOARD_LEFT_CONTROL));
 294         else /* Any other key should be set in a separate byte */
 295             buf[i++] = (uint8_t)key;
 296
 297         id >>= 8;
 298     }
 299
 300     return BUF_LEN_KEYBOARD;
 301 }
 302
 303 #define BUF_LEN_CONSUMER 4
 304 static uint8_t buf_set_consumer(unsigned char *buf, int id)
 305 {
 306     memset(buf, 0, BUF_LEN_CONSUMER);
 307     buf[0] = (uint8_t)id;
 308
 309     return BUF_LEN_CONSUMER;
 310 }
 311
 312 #ifdef HAVE_USB_HID_MOUSE
 313 #define MOUSE_WHEEL_STEP       1
 314 #define MOUSE_STEP             8
 315 #define MOUSE_BUTTON_LEFT    0x1
 316 #define MOUSE_BUTTON_RIGHT   0x2
 317 //#define MOUSE_BUTTON_MIDDLE  0x4
 318 #define MOUSE_BUTTON           0
 319 #define MOUSE_X                1
 320 #define MOUSE_Y                2
 321 #define MOUSE_WHEEL            3
 322 #define BUF_LEN_MOUSE          4
 323 #define MOUSE_ACCEL_FACTOR(count) ((count) / 2)
 324 #define MOUSE_DO(item, step) (buf[(item)] = ((uint8_t)(step)))
 325
 326 static uint8_t buf_set_mouse(unsigned char *buf, int id)
 327 {
 328     static int count = 0;
 329     int step = MOUSE_STEP;
 330
 331     memset(buf, 0, BUF_LEN_MOUSE);
 332
 333     /* Set proper button */
 334     switch (id)
 335     {
 336         case HID_MOUSE_BUTTON_LEFT:
 337         case HID_MOUSE_LDRAG_UP:
 338         case HID_MOUSE_LDRAG_UP_REP:
 339         case HID_MOUSE_LDRAG_DOWN:
 340         case HID_MOUSE_LDRAG_DOWN_REP:
 341         case HID_MOUSE_LDRAG_LEFT:
 342         case HID_MOUSE_LDRAG_LEFT_REP:
 343         case HID_MOUSE_LDRAG_RIGHT:
 344         case HID_MOUSE_LDRAG_RIGHT_REP:
 345             MOUSE_DO(MOUSE_BUTTON, MOUSE_BUTTON_LEFT);
 346             break;
 347         case HID_MOUSE_BUTTON_RIGHT:
 348         case HID_MOUSE_RDRAG_UP:
 349         case HID_MOUSE_RDRAG_UP_REP:
 350         case HID_MOUSE_RDRAG_DOWN:
 351         case HID_MOUSE_RDRAG_DOWN_REP:
 352         case HID_MOUSE_RDRAG_LEFT:
 353         case HID_MOUSE_RDRAG_LEFT_REP:
 354         case HID_MOUSE_RDRAG_RIGHT:
 355         case HID_MOUSE_RDRAG_RIGHT_REP:
 356             MOUSE_DO(MOUSE_BUTTON, MOUSE_BUTTON_RIGHT);
 357             break;
 358         case HID_MOUSE_BUTTON_LEFT_REL:
 359         case HID_MOUSE_BUTTON_RIGHT_REL:
 360             /* Keep buf empty, to mark mouse button release */
 361             break;
 362         default:
 363             break;
 364     }
 365
 366     /* Handle mouse accelarated movement */
 367     switch (id)
 368     {
 369         case HID_MOUSE_UP:
 370         case HID_MOUSE_DOWN:
 371         case HID_MOUSE_LEFT:
 372         case HID_MOUSE_RIGHT:
 373         case HID_MOUSE_LDRAG_UP:
 374         case HID_MOUSE_LDRAG_DOWN:
 375         case HID_MOUSE_LDRAG_LEFT:
 376         case HID_MOUSE_LDRAG_RIGHT:
 377         case HID_MOUSE_RDRAG_UP:
 378         case HID_MOUSE_RDRAG_DOWN:
 379         case HID_MOUSE_RDRAG_LEFT:
 380         case HID_MOUSE_RDRAG_RIGHT:
 381             count = 0;
 382             break;
 383         case HID_MOUSE_UP_REP:
 384         case HID_MOUSE_DOWN_REP:
 385         case HID_MOUSE_LEFT_REP:
 386         case HID_MOUSE_RIGHT_REP:
 387         case HID_MOUSE_LDRAG_UP_REP:
 388         case HID_MOUSE_LDRAG_DOWN_REP:
 389         case HID_MOUSE_LDRAG_LEFT_REP:
 390         case HID_MOUSE_LDRAG_RIGHT_REP:
 391         case HID_MOUSE_RDRAG_UP_REP:
 392         case HID_MOUSE_RDRAG_DOWN_REP:
 393         case HID_MOUSE_RDRAG_LEFT_REP:
 394         case HID_MOUSE_RDRAG_RIGHT_REP:
 395             count++;
 396             /* TODO: Find a better mouse accellaration algorithm */
 397             step *= 1 + MOUSE_ACCEL_FACTOR(count);
 398             if (step > 255)
 399                 step = 255;
 400             break;
 401         default:
 402             break;
 403     }
 404
 405     /* Move/scroll mouse */
 406     switch (id)
 407     {
 408         case HID_MOUSE_UP:
 409         case HID_MOUSE_UP_REP:
 410         case HID_MOUSE_LDRAG_UP:
 411         case HID_MOUSE_LDRAG_UP_REP:
 412         case HID_MOUSE_RDRAG_UP:
 413         case HID_MOUSE_RDRAG_UP_REP:
 414             MOUSE_DO(MOUSE_Y, -step);
 415             break;
 416         case HID_MOUSE_DOWN:
 417         case HID_MOUSE_DOWN_REP:
 418         case HID_MOUSE_LDRAG_DOWN:
 419         case HID_MOUSE_LDRAG_DOWN_REP:
 420         case HID_MOUSE_RDRAG_DOWN:
 421         case HID_MOUSE_RDRAG_DOWN_REP:
 422             MOUSE_DO(MOUSE_Y, step);
 423             break;
 424         case HID_MOUSE_LEFT:
 425         case HID_MOUSE_LEFT_REP:
 426         case HID_MOUSE_LDRAG_LEFT:
 427         case HID_MOUSE_LDRAG_LEFT_REP:
 428         case HID_MOUSE_RDRAG_LEFT:
 429         case HID_MOUSE_RDRAG_LEFT_REP:
 430             MOUSE_DO(MOUSE_X, -step);
 431             break;
 432         case HID_MOUSE_RIGHT:
 433         case HID_MOUSE_RIGHT_REP:
 434         case HID_MOUSE_LDRAG_RIGHT:
 435         case HID_MOUSE_LDRAG_RIGHT_REP:
 436         case HID_MOUSE_RDRAG_RIGHT:
 437         case HID_MOUSE_RDRAG_RIGHT_REP:
 438             MOUSE_DO(MOUSE_X, step);
 439             break;
 440         case HID_MOUSE_SCROLL_UP:
 441             MOUSE_DO(MOUSE_WHEEL, MOUSE_WHEEL_STEP);
 442             break;
 443         case HID_MOUSE_SCROLL_DOWN:
 444             MOUSE_DO(MOUSE_WHEEL, -MOUSE_WHEEL_STEP);
 445             break;
 446         default:
 447             break;
 448     }
 449
 450     return BUF_LEN_MOUSE;
 451 }
 452 #endif /* HAVE_USB_HID_MOUSE */
 453
 454 static size_t descriptor_report_get(unsigned char *dest)
 455 {
 456     unsigned char *report = dest;
 457     usb_hid_report_t *usb_hid_report;
 458
 459     /* Keyboard control */
 460     usb_hid_report = &usb_hid_reports[REPORT_ID_KEYBOARD];
 461     usb_hid_report->usage_page = HID_USAGE_PAGE_KEYBOARD_KEYPAD;
 462     usb_hid_report->buf_set = buf_set_keyboard;
 463     usb_hid_report->is_key_released = 1;
 464
 465     pack_parameter(&report, 0, 1, USAGE_PAGE,
 466             HID_USAGE_PAGE_GENERIC_DESKTOP_CONTROLS);
 467     pack_parameter(&report, 0, 0, CONSUMER_USAGE, HID_GENERIC_DESKTOP_KEYBOARD);
 468     pack_parameter(&report, 0, 1, COLLECTION, COLLECTION_APPLICATION);
 469     pack_parameter(&report, 0, 1, REPORT_ID, REPORT_ID_KEYBOARD);
 470     pack_parameter(&report, 0, 1, USAGE_PAGE, HID_GENERIC_DESKTOP_KEYPAD);
 471     pack_parameter(&report, 0, 1, USAGE_MINIMUM, HID_KEYBOARD_LEFT_CONTROL);
 472     pack_parameter(&report, 0, 1, USAGE_MAXIMUM, HID_KEYBOARD_RIGHT_GUI);
 473     pack_parameter(&report, 1, 1, LOGICAL_MINIMUM, 0);
 474     pack_parameter(&report, 1, 1, LOGICAL_MAXIMUM, 1);
 475     pack_parameter(&report, 0, 1, REPORT_SIZE, 1);
 476     pack_parameter(&report, 0, 1, REPORT_COUNT, 8);
 477     pack_parameter(&report, 0, 1, INPUT, MAIN_ITEM_VARIABLE);
 478     pack_parameter(&report, 0, 1, REPORT_SIZE, 1);
 479     pack_parameter(&report, 0, 1, REPORT_COUNT, 5);
 480     pack_parameter(&report, 0, 1, USAGE_PAGE, HID_USAGE_PAGE_LEDS);
 481     pack_parameter(&report, 0, 1, USAGE_MINIMUM, HID_LED_NUM_LOCK);
 482     pack_parameter(&report, 0, 1, USAGE_MAXIMUM, HID_LED_KANA);
 483     pack_parameter(&report, 0, 1, OUTPUT, MAIN_ITEM_VARIABLE);
 484     pack_parameter(&report, 0, 1, REPORT_SIZE, 3);
 485     pack_parameter(&report, 0, 1, REPORT_COUNT, 1);
 486     pack_parameter(&report, 0, 1, OUTPUT, MAIN_ITEM_CONSTANT);
 487     pack_parameter(&report, 0, 1, REPORT_SIZE, 8);
 488     pack_parameter(&report, 0, 1, REPORT_COUNT, 6);
 489     pack_parameter(&report, 1, 1, LOGICAL_MINIMUM, 0);
 490     pack_parameter(&report, 1, 1, LOGICAL_MAXIMUM, HID_KEYBOARD_EX_SEL);
 491     pack_parameter(&report, 0, 1, USAGE_PAGE, HID_USAGE_PAGE_KEYBOARD_KEYPAD);
 492     pack_parameter(&report, 0, 1, USAGE_MINIMUM, 0);
 493     pack_parameter(&report, 0, 1, USAGE_MAXIMUM, HID_KEYBOARD_EX_SEL);
 494     pack_parameter(&report, 0, 1, INPUT, 0);
 495     PACK_VAL(report, END_COLLECTION);
 496
 497     /* Consumer usage controls - play/pause, stop, etc. */
 498     usb_hid_report = &usb_hid_reports[REPORT_ID_CONSUMER];
 499     usb_hid_report->usage_page = HID_USAGE_PAGE_CONSUMER;
 500     usb_hid_report->buf_set = buf_set_consumer;
 501     usb_hid_report->is_key_released = 1;
 502
 503     pack_parameter(&report, 0, 1, USAGE_PAGE, HID_USAGE_PAGE_CONSUMER);
 504     pack_parameter(&report, 0, 0, CONSUMER_USAGE,
 505             HID_CONSUMER_USAGE_CONSUMER_CONTROL);
 506     pack_parameter(&report, 0, 1, COLLECTION, COLLECTION_APPLICATION);
 507     pack_parameter(&report, 0, 1, REPORT_ID, REPORT_ID_CONSUMER);
 508     pack_parameter(&report, 0, 1, REPORT_SIZE, 16);
 509     pack_parameter(&report, 0, 1, REPORT_COUNT, 2);
 510     pack_parameter(&report, 1, 1, LOGICAL_MINIMUM, 1);
 511     pack_parameter(&report, 1, 1, LOGICAL_MAXIMUM, 652);
 512     pack_parameter(&report, 0, 1, USAGE_MINIMUM,
 513             HID_CONSUMER_USAGE_CONSUMER_CONTROL);
 514     pack_parameter(&report, 0, 1, USAGE_MAXIMUM, HID_CONSUMER_USAGE_AC_SEND);
 515     pack_parameter(&report, 0, 1, INPUT, MAIN_ITEM_NO_PREFERRED |
 516             MAIN_ITEM_NULL_STATE);
 517     PACK_VAL(report, END_COLLECTION);
 518
 519 #ifdef HAVE_USB_HID_MOUSE
 520     /* Mouse control */
 521     usb_hid_report = &usb_hid_reports[REPORT_ID_MOUSE];
 522     usb_hid_report->usage_page = HID_USAGE_PAGE_GENERIC_DESKTOP_CONTROLS;
 523     usb_hid_report->buf_set = buf_set_mouse;
 524     usb_hid_report->is_key_released = 0;
 525
 526     pack_parameter(&report, 0, 1, USAGE_PAGE,
 527             HID_USAGE_PAGE_GENERIC_DESKTOP_CONTROLS);
 528     pack_parameter(&report, 0, 0, CONSUMER_USAGE, HID_GENERIC_DESKTOP_MOUSE);
 529     pack_parameter(&report, 0, 1, COLLECTION, COLLECTION_APPLICATION);
 530     pack_parameter(&report, 0, 1, REPORT_ID, REPORT_ID_MOUSE);
 531     pack_parameter(&report, 0, 0, CONSUMER_USAGE, HID_GENERIC_DESKTOP_POINTER);
 532     pack_parameter(&report, 0, 1, COLLECTION, COLLECTION_PHYSICAL);
 533     pack_parameter(&report, 0, 1, USAGE_PAGE, HID_USAGE_PAGE_BUTTON);
 534     pack_parameter(&report, 0, 1, USAGE_MINIMUM, 1);
 535     pack_parameter(&report, 0, 1, USAGE_MAXIMUM, 8);
 536     pack_parameter(&report, 1, 1, LOGICAL_MINIMUM, 0);
 537     pack_parameter(&report, 1, 1, LOGICAL_MAXIMUM, 1);
 538     pack_parameter(&report, 0, 1, REPORT_SIZE, 1);
 539     pack_parameter(&report, 0, 1, REPORT_COUNT, 8);
 540     pack_parameter(&report, 0, 1, INPUT, MAIN_ITEM_VARIABLE);
 541     pack_parameter(&report, 0, 1, USAGE_PAGE,
 542             HID_USAGE_PAGE_GENERIC_DESKTOP_CONTROLS);
 543     pack_parameter(&report, 0, 0, CONSUMER_USAGE, HID_GENERIC_DESKTOP_X);
 544     pack_parameter(&report, 0, 0, CONSUMER_USAGE, HID_GENERIC_DESKTOP_Y);
 545     pack_parameter(&report, 0, 0, CONSUMER_USAGE, HID_GENERIC_DESKTOP_WHEEL);
 546     pack_parameter(&report, 0, 1, LOGICAL_MINIMUM, -127 & 0xFF);
 547     pack_parameter(&report, 0, 1, LOGICAL_MAXIMUM, 127);
 548     pack_parameter(&report, 0, 1, REPORT_SIZE, 8);
 549     pack_parameter(&report, 0, 1, REPORT_COUNT, 3);
 550     pack_parameter(&report, 0, 1, INPUT, MAIN_ITEM_VARIABLE | MAIN_ITEM_RELATIVE);
 551     PACK_VAL(report, END_COLLECTION);
 552     PACK_VAL(report, END_COLLECTION);
 553 #endif /* HAVE_USB_HID_MOUSE */
 554
 555     return (size_t)(report - dest);
 556 }
 557
 558 static void descriptor_hid_get(unsigned char **dest)
 559 {
 560     hid_descriptor.wDescriptorLength0 =
 561         (uint16_t)descriptor_report_get(report_descriptor);
 562
 563     logf("hid: desc len %u", hid_descriptor.wDescriptorLength0);
 564     buf_dump(report_descriptor, hid_descriptor.wDescriptorLength0, "desc");
 565
 566     PACK_DATA(*dest, hid_descriptor);
 567 }
 568
 569 int usb_hid_get_config_descriptor(unsigned char *dest, int max_packet_size)
 570 {
 571     unsigned char *orig_dest = dest;
 572
 573     logf("hid: config desc.");
 574
 575     /* Ignore given max_packet_size */
 576     (void)max_packet_size;
 577
 578     /* Interface descriptor */
 579     interface_descriptor.bInterfaceNumber = usb_interface;
 580     PACK_DATA(dest, interface_descriptor);
 581
 582     /* HID descriptor */
 583     descriptor_hid_get(&dest);
 584
 585     /* Endpoint descriptor */
 586     endpoint_descriptor.wMaxPacketSize = 8;
 587     endpoint_descriptor.bInterval = 8;
 588     endpoint_descriptor.bEndpointAddress = ep_in;
 589     PACK_DATA(dest, endpoint_descriptor);
 590
 591     return (int)(dest - orig_dest);
 592 }
 593
 594 void usb_hid_init_connection(void)
 595 {
 596     logf("hid: init connection");
 597
 598     active = true;
 599     currently_sending = false;
 600 }
 601
 602 /* called by usb_core_init() */
 603 void usb_hid_init(void)
 604 {
 605     int i;
 606
 607     logf("hid: init");
 608
 609     for (i = 0; i < HID_NUM_BUFFERS; i++)
 610         send_buffer_len[i] = 0;
 611
 612     cur_buf_prepare = 0;
 613     cur_buf_send = 0;
 614
 615     active = true;
 616     currently_sending = false;
 617 }
 618
 619 void usb_hid_disconnect(void)
 620 {
 621     logf("hid: disconnect");
 622     active = false;
 623     currently_sending = false;
 624 }
 625
 626 /* called by usb_core_transfer_complete() */
 627 void usb_hid_transfer_complete(int ep, int dir, int status, int length)
 628 {
 629     (void)ep;
 630     (void)dir;
 631     (void)status;
 632     (void)length;
 633
 634     logf("HID: transfer complete: %d %d %d %d",ep,dir,status,length);
 635     switch (dir)
 636     {
 637         case USB_DIR_OUT:
 638             break;
 639         case USB_DIR_IN:
 640         {
 641             if (status)
 642                 break;
 643
 644             send_buffer_len[cur_buf_send] = 0;
 645             HID_BUF_INC(cur_buf_send);
 646             currently_sending = false;
 647             usb_hid_try_send_drv();
 648             break;
 649         }
 650     }
 651 }
 652
 653 /* The DAP is registered as a keyboard with several LEDs, therefore the OS sends
 654  * LED report to notify the DAP whether Num Lock / Caps Lock etc. are enabled.
 655  * In order to allow sending info to the DAP, the Set Report mechanism can be
 656  * used by defining vendor specific output reports and send them from the host
 657  * to the DAP using the host's custom driver */
 658 static int usb_hid_set_report(struct usb_ctrlrequest *req)
 659 {
 660     static unsigned char buf[SET_REPORT_BUF_LEN] USB_DEVBSS_ATTR
 661         __attribute__((aligned(32)));
 662     int length;
 663     int rc = 0;
 664
 665     if ((req->wValue >> 8) != REPORT_TYPE_OUTPUT)
 666     {
 667         logf("Unsopported report type");
 668         rc = 1;
 669         goto Exit;
 670     }
 671     if ((req->wValue & 0xff) != REPORT_ID_KEYBOARD)
 672     {
 673         logf("Wrong report id");
 674         rc = 2;
 675         goto Exit;
 676     }
 677     if (req->wIndex != (uint16_t)usb_interface)
 678     {
 679         logf("Wrong interface");
 680         rc = 3;
 681         goto Exit;
 682     }
 683     length = req->wLength;
 684     if (length != SET_REPORT_BUF_LEN)
 685     {
 686         logf("Wrong length");
 687         rc = 4;
 688         goto Exit;
 689     }
 690
 691     memset(buf, 0, length);
 692     usb_drv_recv(EP_CONTROL, buf, length);
 693
 694 #ifdef LOGF_ENABLE
 695     if (buf[1] & 0x01)
 696         logf("Num Lock enabled");
 697     if (buf[1] & 0x02)
 698         logf("Caps Lock enabled");
 699     if (buf[1] & 0x04)
 700         logf("Scroll Lock enabled");
 701     if (buf[1] & 0x08)
 702         logf("Compose enabled");
 703     if (buf[1] & 0x10)
 704         logf("Kana enabled");
 705 #endif
 706
 707     /* Defining other LEDs and setting them from the USB host (OS) can be used
 708      * to send messages to the DAP */
 709
 710 Exit:
 711     return rc;
 712 }
 713
 714 /* called by usb_core_control_request() */
 715 bool usb_hid_control_request(struct usb_ctrlrequest *req, unsigned char *dest)
 716 {
 717     bool handled = false;
 718
 719     switch (req->bRequestType & USB_TYPE_MASK)
 720     {
 721         case USB_TYPE_STANDARD:
 722         {
 723             unsigned char *orig_dest = dest;
 724
 725             switch (req->wValue>>8) /* type */
 726             {
 727                 case USB_DT_HID:
 728                 {
 729                     logf("hid: type hid");
 730                     descriptor_hid_get(&dest);
 731                     break;
 732                 }
 733                 case USB_DT_REPORT:
 734                 {
 735                     int len;
 736
 737                     logf("hid: type report");
 738
 739                     len = descriptor_report_get(report_descriptor);
 740                     memcpy(dest, &report_descriptor, len);
 741                     dest += len;
 742                     break;
 743                 }
 744                 default:
 745                     logf("hid: unsup. std. req");
 746                     break;
 747             }
 748             if (dest != orig_dest)
 749             {
 750                 usb_drv_recv(EP_CONTROL, NULL, 0); /* ack */
 751                 usb_drv_send(EP_CONTROL, orig_dest, dest - orig_dest);
 752                 handled = true;
 753             }
 754             break;
 755         }
 756
 757         case USB_TYPE_CLASS:
 758         {
 759             switch (req->bRequest)
 760             {
 761                 case USB_HID_SET_IDLE:
 762                     logf("hid: set idle");
 763                     usb_drv_send(EP_CONTROL, NULL, 0); /* ack */
 764                     handled = true;
 765                     break;
 766                 case USB_HID_SET_REPORT:
 767                     logf("hid: set report");
 768                     if (!usb_hid_set_report(req))
 769                     {
 770                         usb_drv_send(EP_CONTROL, NULL, 0); /* ack */
 771                         handled = true;
 772                     }
 773                     break;
 774                 default:
 775                     logf("%d: unsup. cls. req", req->bRequest);
 776                     break;
 777             }
 778             break;
 779         }
 780
 781         case USB_TYPE_VENDOR:
 782             logf("hid: unsup. ven. req");
 783             break;
 784     }
 785     return handled;
 786 }
 787
 788 static void usb_hid_try_send_drv(void)
 789 {
 790     int rc;
 791     int length = send_buffer_len[cur_buf_send];
 792
 793     if (!length)
 794         return;
 795
 796     if (currently_sending)
 797     {
 798         logf("HID: Already sending");
 799         return;
 800     }
 801
 802     logf("HID: Sending %d bytes",length);
 803     rc = usb_drv_send_nonblocking(ep_in, send_buffer[cur_buf_send], length);
 804     currently_sending = true;
 805     if (rc)
 806     {
 807         send_buffer_len[cur_buf_send] = 0;
 808         return;
 809     }
 810 }
 811
 812 static void usb_hid_queue(unsigned char *data, int length)
 813 {
 814     if (!active || length <= 0)
 815         return;
 816
 817     /* Buffer overflow - item still in use */
 818     if (send_buffer_len[cur_buf_prepare])
 819         return;
 820
 821     /* Prepare buffer for sending */
 822     if (length > HID_BUF_SIZE_MSG)
 823         length = HID_BUF_SIZE_MSG;
 824     memcpy(send_buffer[cur_buf_prepare], data, length);
 825     send_buffer_len[cur_buf_prepare] = length;
 826
 827     HID_BUF_INC(cur_buf_prepare);
 828 }
 829
 830 void usb_hid_send(usage_page_t usage_page, int id)
 831 {
 832     uint8_t report_id, length;
 833     static unsigned char buf[HID_BUF_SIZE_CMD] USB_DEVBSS_ATTR
 834         __attribute__((aligned(32)));
 835     usb_hid_report_t *report = NULL;
 836
 837     for (report_id = 1; report_id < REPORT_ID_COUNT; report_id++)
 838     {
 839         if (usb_hid_reports[report_id].usage_page == usage_page)
 840         {
 841             report = &usb_hid_reports[report_id];
 842             break;
 843         }
 844     }
 845     if (!report)
 846     {
 847         logf("Unsupported usage_page");
 848         return;
 849     }
 850
 851     logf("Sending cmd 0x%x", id);
 852     buf[0] = report_id;
 853     length = report->buf_set(&buf[1], id) + 1;
 854     logf("length %u", length);
 855
 856     if (!length)
 857         return;
 858
 859     /* Key pressed */
 860     buf_dump(buf, length, "key press");
 861     usb_hid_queue(buf, length);
 862
 863     if (report->is_key_released)
 864     {
 865         /* Key released */
 866         memset(buf, 0, length);
 867         buf[0] = report_id;
 868
 869         buf_dump(buf, length, "key release");
 870         usb_hid_queue(buf, length);
 871     }
 872
 873     usb_hid_try_send_drv();
 874 }