EdkModulePkg/Bus/Usb/UsbMouse/Dxe/mousehid.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   Mousehid.c
  15
  16 Abstract:
  17   Parse mouse hid descriptor
  18
  19 --*/
  20
  21 #include "usbmouse.h"
  22 #include "mousehid.h"
  23
  24 //
  25 // Get an item from report descriptor
  26 //
  27 STATIC
  28 UINT8 *
  29 GetNextItem (
  30   IN  UINT8    *StartPos,
  31   IN  UINT8    *EndPos,
  32   OUT HID_ITEM *HidItem
  33   )
  34 /*++
  35
  36 Routine Description:
  37
  38   Get Next Item
  39
  40 Arguments:
  41
  42   StartPos  - Start Position
  43   EndPos    - End Position
  44   HidItem   - HidItem to return
  45
  46 Returns:
  47   Position
  48
  49 --*/
  50 {
  51   UINT8 Temp;
  52
  53   if ((EndPos - StartPos) <= 0) {
  54     return NULL;
  55   }
  56
  57   Temp = *StartPos;
  58   StartPos++;
  59   //
  60   // bit 2,3
  61   //
  62   HidItem->Type = (UINT8) ((Temp >> 2) & 0x03);
  63   //
  64   // bit 4-7
  65   //
  66   HidItem->Tag = (UINT8) ((Temp >> 4) & 0x0F);
  67
  68   if (HidItem->Tag == HID_ITEM_TAG_LONG) {
  69     //
  70     // Long Items are not supported by HID rev1.0,
  71     // although we try to parse it.
  72     //
  73     HidItem->Format = HID_ITEM_FORMAT_LONG;
  74
  75     if ((EndPos - StartPos) >= 2) {
  76       HidItem->Size = *StartPos++;
  77       HidItem->Tag  = *StartPos++;
  78
  79       if ((EndPos - StartPos) >= HidItem->Size) {
  80         HidItem->Data.LongData = StartPos;
  81         StartPos += HidItem->Size;
  82         return StartPos;
  83       }
  84     }
  85   } else {
  86     HidItem->Format = HID_ITEM_FORMAT_SHORT;
  87     //
  88     // bit 0, 1
  89     //
  90     HidItem->Size   = (UINT8) (Temp & 0x03);
  91     switch (HidItem->Size) {
  92
  93     case 0:
  94       //
  95       // No data
  96       //
  97       return StartPos;
  98
  99     case 1:
 100       //
 101       // One byte data
 102       //
 103       if ((EndPos - StartPos) >= 1) {
 104         HidItem->Data.U8 = *StartPos++;
 105         return StartPos;
 106       }
 107
 108     case 2:
 109       //
 110       // Two byte data
 111       //
 112       if ((EndPos - StartPos) >= 2) {
 113         CopyMem (&HidItem->Data.U16, StartPos, sizeof (UINT16));
 114         StartPos += 2;
 115         return StartPos;
 116       }
 117
 118     case 3:
 119       //
 120       // 4 byte data, adjust size
 121       //
 122       HidItem->Size++;
 123       if ((EndPos - StartPos) >= 4) {
 124         CopyMem (&HidItem->Data.U32, StartPos, sizeof (UINT32));
 125         StartPos += 4;
 126         return StartPos;
 127       }
 128     }
 129   }
 130
 131   return NULL;
 132 }
 133
 134 STATIC
 135 UINT32
 136 GetItemData (
 137   IN  HID_ITEM *HidItem
 138   )
 139 /*++
 140
 141 Routine Description:
 142
 143   Get Item Data
 144
 145 Arguments:
 146
 147   HidItem - HID_ITEM
 148
 149 Returns:
 150   HidItem Data
 151
 152
 153 --*/
 154 {
 155   //
 156   // Get Data from HID_ITEM structure
 157   //
 158   switch (HidItem->Size) {
 159
 160   case 1:
 161     return HidItem->Data.U8;
 162
 163   case 2:
 164     return HidItem->Data.U16;
 165
 166   case 4:
 167     return HidItem->Data.U32;
 168   }
 169
 170   return 0;
 171 }
 172
 173 STATIC
 174 VOID
 175 ParseLocalItem (
 176   IN  USB_MOUSE_DEV   *UsbMouse,
 177   IN  HID_ITEM        *LocalItem
 178   )
 179 /*++
 180
 181 Routine Description:
 182
 183   Parse Local Item
 184
 185 Arguments:
 186
 187   UsbMouse  - USB_MOUSE_DEV
 188   LocalItem - Local Item
 189
 190 Returns:
 191
 192 --*/
 193 {
 194   UINT32  Data;
 195
 196   if (LocalItem->Size == 0) {
 197     //
 198     // No expected data for local item
 199     //
 200     return ;
 201   }
 202
 203   Data = GetItemData (LocalItem);
 204
 205   switch (LocalItem->Tag) {
 206
 207   case HID_LOCAL_ITEM_TAG_DELIMITER:
 208     //
 209     // we don't support delimiter here
 210     //
 211     return ;
 212
 213   case HID_LOCAL_ITEM_TAG_USAGE:
 214     return ;
 215
 216   case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 217     if (UsbMouse->PrivateData.ButtonDetected) {
 218       UsbMouse->PrivateData.ButtonMinIndex = (UINT8) Data;
 219     }
 220
 221     return ;
 222
 223   case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 224     {
 225       if (UsbMouse->PrivateData.ButtonDetected) {
 226         UsbMouse->PrivateData.ButtonMaxIndex = (UINT8) Data;
 227       }
 228
 229       return ;
 230     }
 231   }
 232 }
 233
 234 STATIC
 235 VOID
 236 ParseGlobalItem (
 237   IN  USB_MOUSE_DEV   *UsbMouse,
 238   IN  HID_ITEM        *GlobalItem
 239   )
 240 {
 241   UINT8 UsagePage;
 242
 243   switch (GlobalItem->Tag) {
 244   case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 245     {
 246       UsagePage = (UINT8) GetItemData (GlobalItem);
 247
 248       //
 249       // We only care Button Page here
 250       //
 251       if (UsagePage == 0x09) {
 252         //
 253         // Button Page
 254         //
 255         UsbMouse->PrivateData.ButtonDetected = TRUE;
 256         return ;
 257       }
 258       break;
 259     }
 260
 261   }
 262 }
 263
 264
 265 STATIC
 266 VOID
 267 ParseMainItem (
 268   IN  USB_MOUSE_DEV   *UsbMouse,
 269   IN  HID_ITEM        *MainItem
 270   )
 271 /*++
 272
 273 Routine Description:
 274
 275   Parse Main Item
 276
 277 Arguments:
 278
 279   UsbMouse  - TODO: add argument description
 280   MainItem  - HID_ITEM to parse
 281
 282 Returns:
 283
 284   VOID
 285
 286 --*/
 287 {
 288   //
 289   // we don't care any main items, just skip
 290   //
 291   return ;
 292 }
 293
 294 STATIC
 295 VOID
 296 ParseHidItem (
 297   IN  USB_MOUSE_DEV   *UsbMouse,
 298   IN  HID_ITEM        *HidItem
 299   )
 300 /*++
 301
 302 Routine Description:
 303
 304   Parse Hid Item
 305
 306 Arguments:
 307
 308   UsbMouse  - USB_MOUSE_DEV
 309   HidItem   - HidItem to parse
 310
 311 Returns:
 312
 313   VOID
 314
 315 --*/
 316 {
 317   switch (HidItem->Type) {
 318
 319   case HID_ITEM_TYPE_MAIN:
 320     //
 321     // For Main Item, parse main item
 322     //
 323     ParseMainItem (UsbMouse, HidItem);
 324     break;
 325
 326   case HID_ITEM_TYPE_GLOBAL:
 327     //
 328     // For global Item, parse global item
 329     //
 330     ParseGlobalItem (UsbMouse, HidItem);
 331     break;
 332
 333   case HID_ITEM_TYPE_LOCAL:
 334     //
 335     // For Local Item, parse local item
 336     //
 337     ParseLocalItem (UsbMouse, HidItem);
 338     break;
 339   }
 340 }
 341 //
 342 // A simple parse just read some field we are interested in
 343 //
 344 EFI_STATUS
 345 ParseMouseReportDescriptor (
 346   IN  USB_MOUSE_DEV   *UsbMouse,
 347   IN  UINT8           *ReportDescriptor,
 348   IN  UINTN           ReportSize
 349   )
 350 /*++
 351
 352 Routine Description:
 353
 354   Parse Mouse Report Descriptor
 355
 356 Arguments:
 357
 358   UsbMouse          - USB_MOUSE_DEV
 359   ReportDescriptor  - Report descriptor to parse
 360   ReportSize        - Report descriptor size
 361
 362 Returns:
 363
 364   EFI_DEVICE_ERROR - Report descriptor error
 365   EFI_SUCCESS      - Success
 366
 367 --*/
 368 {
 369   UINT8     *DescriptorEnd;
 370   UINT8     *ptr;
 371   HID_ITEM  HidItem;
 372
 373   DescriptorEnd = ReportDescriptor + ReportSize;
 374
 375   ptr           = GetNextItem (ReportDescriptor, DescriptorEnd, &HidItem);
 376
 377   while (ptr != NULL) {
 378     if (HidItem.Format != HID_ITEM_FORMAT_SHORT) {
 379       //
 380       // Long Format Item is not supported at current HID revision
 381       //
 382       return EFI_DEVICE_ERROR;
 383     }
 384
 385     ParseHidItem (UsbMouse, &HidItem);
 386
 387     ptr = GetNextItem (ptr, DescriptorEnd, &HidItem);
 388   }
 389
 390   UsbMouse->NumberOfButtons                 = (UINT8) (UsbMouse->PrivateData.ButtonMaxIndex - UsbMouse->PrivateData.ButtonMinIndex + 1);
 391   UsbMouse->XLogicMax                       = UsbMouse->YLogicMax = 127;
 392   UsbMouse->XLogicMin                       = UsbMouse->YLogicMin = -127;
 393
 394   return EFI_SUCCESS;
 395 }