MdeModulePkg/Bus/Usb/UsbMouseAbsolutePointerDxe/mousehid.c

   1 /** @file
   2
   3 Copyright (c) 2004, 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
  22 #include "mousehid.h"
  23
  24
  25 //
  26 // Get an item from report descriptor
  27 //
  28
  29 /**
  30   Get Next Item
  31
  32   @param  StartPos          Start Position
  33   @param  EndPos            End Position
  34   @param  HidItem           HidItem to return
  35
  36   @return Position
  37
  38 **/
  39 UINT8 *
  40 GetNextItem (
  41   IN  UINT8    *StartPos,
  42   IN  UINT8    *EndPos,
  43   OUT HID_ITEM *HidItem
  44   )
  45 {
  46   UINT8 Temp;
  47
  48   if ((EndPos - StartPos) <= 0) {
  49     return NULL;
  50   }
  51
  52   Temp = *StartPos;
  53   StartPos++;
  54   //
  55   // bit 2,3
  56   //
  57   HidItem->Type = (UINT8) ((Temp >> 2) & 0x03);
  58   //
  59   // bit 4-7
  60   //
  61   HidItem->Tag = (UINT8) ((Temp >> 4) & 0x0F);
  62
  63   if (HidItem->Tag == HID_ITEM_TAG_LONG) {
  64     //
  65     // Long Items are not supported by HID rev1.0,
  66     // although we try to parse it.
  67     //
  68     HidItem->Format = HID_ITEM_FORMAT_LONG;
  69
  70     if ((EndPos - StartPos) >= 2) {
  71       HidItem->Size = *StartPos++;
  72       HidItem->Tag  = *StartPos++;
  73
  74       if ((EndPos - StartPos) >= HidItem->Size) {
  75         HidItem->Data.LongData = StartPos;
  76         StartPos += HidItem->Size;
  77         return StartPos;
  78       }
  79     }
  80   } else {
  81     HidItem->Format = HID_ITEM_FORMAT_SHORT;
  82     //
  83     // bit 0, 1
  84     //
  85     HidItem->Size   = (UINT8) (Temp & 0x03);
  86     switch (HidItem->Size) {
  87
  88     case 0:
  89       //
  90       // No data
  91       //
  92       return StartPos;
  93
  94     case 1:
  95       //
  96       // One byte data
  97       //
  98       if ((EndPos - StartPos) >= 1) {
  99         HidItem->Data.U8 = *StartPos++;
 100         return StartPos;
 101       }
 102
 103     case 2:
 104       //
 105       // Two byte data
 106       //
 107       if ((EndPos - StartPos) >= 2) {
 108         CopyMem (&HidItem->Data.U16, StartPos, sizeof (UINT16));
 109         StartPos += 2;
 110         return StartPos;
 111       }
 112
 113     case 3:
 114       //
 115       // 4 byte data, adjust size
 116       //
 117       HidItem->Size++;
 118       if ((EndPos - StartPos) >= 4) {
 119         CopyMem (&HidItem->Data.U32, StartPos, sizeof (UINT32));
 120         StartPos += 4;
 121         return StartPos;
 122       }
 123     }
 124   }
 125
 126   return NULL;
 127 }
 128
 129
 130 /**
 131   Get Item Data
 132
 133   @param  HidItem           HID_ITEM
 134
 135   @return HidItem Data
 136
 137 **/
 138 UINT32
 139 GetItemData (
 140   IN  HID_ITEM *HidItem
 141   )
 142 {
 143   //
 144   // Get Data from HID_ITEM structure
 145   //
 146   switch (HidItem->Size) {
 147
 148   case 1:
 149     return HidItem->Data.U8;
 150
 151   case 2:
 152     return HidItem->Data.U16;
 153
 154   case 4:
 155     return HidItem->Data.U32;
 156   }
 157
 158   return 0;
 159 }
 160
 161
 162 /**
 163   Parse Local Item
 164
 165   @param  UsbMouseAbsolutePointer          USB_MOUSE_ABSOLUTE_POINTER_DEV
 166   @param  LocalItem         Local Item
 167
 168
 169 **/
 170 VOID
 171 ParseLocalItem (
 172   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointer,
 173   IN  HID_ITEM        *LocalItem
 174   )
 175 {
 176   UINT32  Data;
 177
 178   if (LocalItem->Size == 0) {
 179     //
 180     // No expected data for local item
 181     //
 182     return ;
 183   }
 184
 185   Data = GetItemData (LocalItem);
 186
 187   switch (LocalItem->Tag) {
 188
 189   case HID_LOCAL_ITEM_TAG_DELIMITER:
 190     //
 191     // we don't support delimiter here
 192     //
 193     return ;
 194
 195   case HID_LOCAL_ITEM_TAG_USAGE:
 196     return ;
 197
 198   case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 199     if (UsbMouseAbsolutePointer->PrivateData.ButtonDetected) {
 200       UsbMouseAbsolutePointer->PrivateData.ButtonMinIndex = (UINT8) Data;
 201     }
 202
 203     return ;
 204
 205   case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 206     {
 207       if (UsbMouseAbsolutePointer->PrivateData.ButtonDetected) {
 208         UsbMouseAbsolutePointer->PrivateData.ButtonMaxIndex = (UINT8) Data;
 209       }
 210
 211       return ;
 212     }
 213   }
 214 }
 215
 216 VOID
 217 ParseGlobalItem (
 218   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointer,
 219   IN  HID_ITEM        *GlobalItem
 220   )
 221 {
 222   UINT8 UsagePage;
 223
 224   switch (GlobalItem->Tag) {
 225   case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 226     {
 227       UsagePage = (UINT8) GetItemData (GlobalItem);
 228
 229       //
 230       // We only care Button Page here
 231       //
 232       if (UsagePage == 0x09) {
 233         //
 234         // Button Page
 235         //
 236         UsbMouseAbsolutePointer->PrivateData.ButtonDetected = TRUE;
 237         return ;
 238       }
 239       break;
 240     }
 241
 242   }
 243 }
 244
 245
 246
 247 /**
 248   Parse Main Item
 249
 250   @param  UsbMouseAbsolutePointer   USB_MOUSE_ABSOLUTE_POINTER_DEV
 251   @param  MainItem          HID_ITEM to parse
 252
 253   @return VOID
 254
 255 **/
 256 VOID
 257 ParseMainItem (
 258   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointer,
 259   IN  HID_ITEM        *MainItem
 260   )
 261 {
 262   //
 263   // we don't care any main items, just skip
 264   //
 265   return ;
 266 }
 267
 268
 269 /**
 270   Parse Hid Item
 271
 272   @param  UsbMouseAbsolutePointer          USB_MOUSE_ABSOLUTE_POINTER_DEV
 273   @param  HidItem           HidItem to parse
 274
 275   @return VOID
 276
 277 **/
 278 VOID
 279 ParseHidItem (
 280   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointer,
 281   IN  HID_ITEM        *HidItem
 282   )
 283 {
 284   switch (HidItem->Type) {
 285
 286   case HID_ITEM_TYPE_MAIN:
 287     //
 288     // For Main Item, parse main item
 289     //
 290     ParseMainItem (UsbMouseAbsolutePointer, HidItem);
 291     break;
 292
 293   case HID_ITEM_TYPE_GLOBAL:
 294     //
 295     // For global Item, parse global item
 296     //
 297     ParseGlobalItem (UsbMouseAbsolutePointer, HidItem);
 298     break;
 299
 300   case HID_ITEM_TYPE_LOCAL:
 301     //
 302     // For Local Item, parse local item
 303     //
 304     ParseLocalItem (UsbMouseAbsolutePointer, HidItem);
 305     break;
 306   }
 307 }
 308 //
 309 // A simple parse just read some field we are interested in
 310 //
 311
 312 /**
 313   Parse Mouse Report Descriptor
 314
 315   @param  UsbMouse          USB_MOUSE_DEV
 316   @param  ReportDescriptor  Report descriptor to parse
 317   @param  ReportSize        Report descriptor size
 318
 319   @retval EFI_DEVICE_ERROR  Report descriptor error
 320   @retval EFI_SUCCESS       Success
 321
 322 **/
 323 EFI_STATUS
 324 ParseMouseReportDescriptor (
 325   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointer,
 326   IN  UINT8           *ReportDescriptor,
 327   IN  UINTN           ReportSize
 328   )
 329 {
 330   UINT8     *DescriptorEnd;
 331   UINT8     *ptr;
 332   HID_ITEM  HidItem;
 333
 334   DescriptorEnd = ReportDescriptor + ReportSize;
 335
 336   ptr           = GetNextItem (ReportDescriptor, DescriptorEnd, &HidItem);
 337
 338   while (ptr != NULL) {
 339     if (HidItem.Format != HID_ITEM_FORMAT_SHORT) {
 340       //
 341       // Long Format Item is not supported at current HID revision
 342       //
 343       return EFI_DEVICE_ERROR;
 344     }
 345
 346     ParseHidItem (UsbMouseAbsolutePointer, &HidItem);
 347
 348     ptr = GetNextItem (ptr, DescriptorEnd, &HidItem);
 349   }
 350
 351   UsbMouseAbsolutePointer->NumberOfButtons                 = (UINT8) (UsbMouseAbsolutePointer->PrivateData.ButtonMaxIndex - UsbMouseAbsolutePointer->PrivateData.ButtonMinIndex + 1);
 352   UsbMouseAbsolutePointer->XLogicMax                       = UsbMouseAbsolutePointer->YLogicMax = 1023;
 353   UsbMouseAbsolutePointer->XLogicMin                       = UsbMouseAbsolutePointer->YLogicMin = -1023;
 354
 355   return EFI_SUCCESS;
 356 }