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