drivers/hid/hidclass/hidclass.c

   1 /*
   2  * PROJECT:     ReactOS Universal Serial Bus Human Interface Device Driver
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        drivers/hid/hidclass/hidclass.c
   5  * PURPOSE:     HID Class Driver
   6  * PROGRAMMERS:
   7  *              Michael Martin (michael.martin@reactos.org)
   8  *              Johannes Anderwald (johannes.anderwald@reactos.org)
   9  */
  10
  11 #include "precomp.h"
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 static LPWSTR ClientIdentificationAddress = L"HIDCLASS";
  17 static ULONG HidClassDeviceNumber = 0;
  18
  19 NTSTATUS
  20 NTAPI
  21 DllInitialize(
  22     IN PUNICODE_STRING RegistryPath)
  23 {
  24     return STATUS_SUCCESS;
  25 }
  26
  27 NTSTATUS
  28 NTAPI
  29 DllUnload(VOID)
  30 {
  31     return STATUS_SUCCESS;
  32 }
  33
  34 NTSTATUS
  35 NTAPI
  36 HidClassAddDevice(
  37     IN PDRIVER_OBJECT DriverObject,
  38     IN PDEVICE_OBJECT PhysicalDeviceObject)
  39 {
  40     WCHAR CharDeviceName[64];
  41     NTSTATUS Status;
  42     UNICODE_STRING DeviceName;
  43     PDEVICE_OBJECT NewDeviceObject;
  44     PHIDCLASS_FDO_EXTENSION FDODeviceExtension;
  45     ULONG DeviceExtensionSize;
  46     PHIDCLASS_DRIVER_EXTENSION DriverExtension;
  47
  48     /* increment device number */
  49     InterlockedIncrement((PLONG)&HidClassDeviceNumber);
  50
  51     /* construct device name */
  52     swprintf(CharDeviceName, L"\\Device\\_HID%08x", HidClassDeviceNumber);
  53
  54     /* initialize device name */
  55     RtlInitUnicodeString(&DeviceName, CharDeviceName);
  56
  57     /* get driver object extension */
  58     DriverExtension = IoGetDriverObjectExtension(DriverObject, ClientIdentificationAddress);
  59     if (!DriverExtension)
  60     {
  61         /* device removed */
  62         ASSERT(FALSE);
  63         return STATUS_DEVICE_CONFIGURATION_ERROR;
  64     }
  65
  66     /* calculate device extension size */
  67     DeviceExtensionSize = sizeof(HIDCLASS_FDO_EXTENSION) + DriverExtension->DeviceExtensionSize;
  68
  69     /* now create the device */
  70     Status = IoCreateDevice(DriverObject, DeviceExtensionSize, &DeviceName, FILE_DEVICE_UNKNOWN, 0, FALSE, &NewDeviceObject);
  71     if (!NT_SUCCESS(Status))
  72     {
  73         /* failed to create device object */
  74         ASSERT(FALSE);
  75         return Status;
  76     }
  77
  78     /* get device extension */
  79     FDODeviceExtension = NewDeviceObject->DeviceExtension;
  80
  81     /* zero device extension */
  82     RtlZeroMemory(FDODeviceExtension, sizeof(HIDCLASS_FDO_EXTENSION));
  83
  84     /* initialize device extension */
  85     FDODeviceExtension->Common.IsFDO = TRUE;
  86     FDODeviceExtension->Common.DriverExtension = DriverExtension;
  87     FDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject = PhysicalDeviceObject;
  88     FDODeviceExtension->Common.HidDeviceExtension.MiniDeviceExtension = (PVOID)((ULONG_PTR)FDODeviceExtension + sizeof(HIDCLASS_FDO_EXTENSION));
  89     FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject = IoAttachDeviceToDeviceStack(NewDeviceObject, PhysicalDeviceObject);
  90     if (FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject == NULL)
  91     {
  92         /* no PDO */
  93         IoDeleteDevice(NewDeviceObject);
  94         DPRINT1("[HIDCLASS] failed to attach to device stack\n");
  95         return STATUS_DEVICE_REMOVED;
  96     }
  97
  98     /* sanity check */
  99     ASSERT(FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject);
 100
 101     /* increment stack size */
 102     NewDeviceObject->StackSize++;
 103
 104     /* init device object */
 105     NewDeviceObject->Flags |= DO_BUFFERED_IO | DO_POWER_PAGABLE;
 106     NewDeviceObject->Flags  &= ~DO_DEVICE_INITIALIZING;
 107
 108     /* now call driver provided add device routine */
 109     ASSERT(DriverExtension->AddDevice != 0);
 110     Status = DriverExtension->AddDevice(DriverObject, NewDeviceObject);
 111     if (!NT_SUCCESS(Status))
 112     {
 113         /* failed */
 114         DPRINT1("HIDCLASS: AddDevice failed with %x\n", Status);
 115         IoDetachDevice(FDODeviceExtension->Common.HidDeviceExtension.NextDeviceObject);
 116         IoDeleteDevice(NewDeviceObject);
 117         return Status;
 118     }
 119
 120     /* succeeded */
 121     return Status;
 122 }
 123
 124 VOID
 125 NTAPI
 126 HidClassDriverUnload(
 127     IN PDRIVER_OBJECT DriverObject)
 128 {
 129     UNIMPLEMENTED;
 130 }
 131
 132 NTSTATUS
 133 NTAPI
 134 HidClass_Create(
 135     IN PDEVICE_OBJECT DeviceObject,
 136     IN PIRP Irp)
 137 {
 138     PIO_STACK_LOCATION IoStack;
 139     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
 140     PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
 141     PHIDCLASS_FILEOP_CONTEXT Context;
 142
 143     //
 144     // get device extension
 145     //
 146     CommonDeviceExtension = DeviceObject->DeviceExtension;
 147     if (CommonDeviceExtension->IsFDO)
 148     {
 149          //
 150          // only supported for PDO
 151          //
 152          Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
 153          IoCompleteRequest(Irp, IO_NO_INCREMENT);
 154          return STATUS_UNSUCCESSFUL;
 155     }
 156
 157     //
 158     // must be a PDO
 159     //
 160     ASSERT(CommonDeviceExtension->IsFDO == FALSE);
 161
 162     //
 163     // get device extension
 164     //
 165     PDODeviceExtension = DeviceObject->DeviceExtension;
 166
 167     //
 168     // get stack location
 169     //
 170     IoStack = IoGetCurrentIrpStackLocation(Irp);
 171
 172     DPRINT("ShareAccess %x\n", IoStack->Parameters.Create.ShareAccess);
 173     DPRINT("Options %x\n", IoStack->Parameters.Create.Options);
 174     DPRINT("DesiredAccess %x\n", IoStack->Parameters.Create.SecurityContext->DesiredAccess);
 175
 176     //
 177     // allocate context
 178     //
 179     Context = ExAllocatePoolWithTag(NonPagedPool, sizeof(HIDCLASS_FILEOP_CONTEXT), HIDCLASS_TAG);
 180     if (!Context)
 181     {
 182         //
 183         // no memory
 184         //
 185         Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
 186         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 187         return STATUS_INSUFFICIENT_RESOURCES;
 188     }
 189
 190     //
 191     // init context
 192     //
 193     RtlZeroMemory(Context, sizeof(HIDCLASS_FILEOP_CONTEXT));
 194     Context->DeviceExtension = PDODeviceExtension;
 195     KeInitializeSpinLock(&Context->Lock);
 196     InitializeListHead(&Context->ReadPendingIrpListHead);
 197     InitializeListHead(&Context->IrpCompletedListHead);
 198     KeInitializeEvent(&Context->IrpReadComplete, NotificationEvent, FALSE);
 199
 200     //
 201     // store context
 202     //
 203     ASSERT(IoStack->FileObject);
 204     IoStack->FileObject->FsContext = Context;
 205
 206     //
 207     // done
 208     //
 209     Irp->IoStatus.Status = STATUS_SUCCESS;
 210     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 211     return STATUS_SUCCESS;
 212 }
 213
 214 NTSTATUS
 215 NTAPI
 216 HidClass_Close(
 217     IN PDEVICE_OBJECT DeviceObject,
 218     IN PIRP Irp)
 219 {
 220     PIO_STACK_LOCATION IoStack;
 221     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
 222     PHIDCLASS_FILEOP_CONTEXT IrpContext;
 223     BOOLEAN IsRequestPending = FALSE;
 224     KIRQL OldLevel;
 225     PLIST_ENTRY Entry;
 226     PIRP ListIrp;
 227
 228     //
 229     // get device extension
 230     //
 231     CommonDeviceExtension = DeviceObject->DeviceExtension;
 232
 233     //
 234     // is it a FDO request
 235     //
 236     if (CommonDeviceExtension->IsFDO)
 237     {
 238         //
 239         // how did the request get there
 240         //
 241         Irp->IoStatus.Status = STATUS_INVALID_PARAMETER_1;
 242         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 243         return STATUS_INVALID_PARAMETER_1;
 244     }
 245
 246     //
 247     // get stack location
 248     //
 249     IoStack = IoGetCurrentIrpStackLocation(Irp);
 250
 251     //
 252     // sanity checks
 253     //
 254     ASSERT(IoStack->FileObject);
 255     ASSERT(IoStack->FileObject->FsContext);
 256
 257     //
 258     // get irp context
 259     //
 260     IrpContext = IoStack->FileObject->FsContext;
 261     ASSERT(IrpContext);
 262
 263     //
 264     // acquire lock
 265     //
 266     KeAcquireSpinLock(&IrpContext->Lock, &OldLevel);
 267
 268     if (!IsListEmpty(&IrpContext->ReadPendingIrpListHead))
 269     {
 270         //
 271         // FIXME cancel irp
 272         //
 273         IsRequestPending = TRUE;
 274     }
 275
 276     //
 277     // signal stop
 278     //
 279     IrpContext->StopInProgress = TRUE;
 280
 281     //
 282     // release lock
 283     //
 284     KeReleaseSpinLock(&IrpContext->Lock, OldLevel);
 285
 286     if (IsRequestPending)
 287     {
 288         //
 289         // wait for request to complete
 290         //
 291         DPRINT1("[HIDCLASS] Waiting for read irp completion...\n");
 292         KeWaitForSingleObject(&IrpContext->IrpReadComplete, Executive, KernelMode, FALSE, NULL);
 293     }
 294
 295     //
 296     // acquire lock
 297     //
 298     KeAcquireSpinLock(&IrpContext->Lock, &OldLevel);
 299
 300     //
 301     // sanity check
 302     //
 303     ASSERT(IsListEmpty(&IrpContext->ReadPendingIrpListHead));
 304
 305     //
 306     // now free all irps
 307     //
 308     while (!IsListEmpty(&IrpContext->IrpCompletedListHead))
 309     {
 310         //
 311         // remove head irp
 312         //
 313         Entry = RemoveHeadList(&IrpContext->IrpCompletedListHead);
 314
 315         //
 316         // get irp
 317         //
 318         ListIrp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
 319
 320         //
 321         // free the irp
 322         //
 323         IoFreeIrp(ListIrp);
 324     }
 325
 326     //
 327     // release lock
 328     //
 329     KeReleaseSpinLock(&IrpContext->Lock, OldLevel);
 330
 331     //
 332     // remove context
 333     //
 334     IoStack->FileObject->FsContext = NULL;
 335
 336     //
 337     // free context
 338     //
 339     ExFreePoolWithTag(IrpContext, HIDCLASS_TAG);
 340
 341     //
 342     // complete request
 343     //
 344     Irp->IoStatus.Status = STATUS_SUCCESS;
 345     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 346     return STATUS_SUCCESS;
 347 }
 348
 349 NTSTATUS
 350 NTAPI
 351 HidClass_ReadCompleteIrp(
 352     IN PDEVICE_OBJECT DeviceObject,
 353     IN PIRP Irp,
 354     IN PVOID Ctx)
 355 {
 356     PHIDCLASS_IRP_CONTEXT IrpContext;
 357     KIRQL OldLevel;
 358     PUCHAR Address;
 359     ULONG Offset;
 360     PHIDP_COLLECTION_DESC CollectionDescription;
 361     PHIDP_REPORT_IDS ReportDescription;
 362     BOOLEAN IsEmpty;
 363
 364     //
 365     // get irp context
 366     //
 367     IrpContext = Ctx;
 368
 369     DPRINT("HidClass_ReadCompleteIrp Irql %lu\n", KeGetCurrentIrql());
 370     DPRINT("HidClass_ReadCompleteIrp Status %lx\n", Irp->IoStatus.Status);
 371     DPRINT("HidClass_ReadCompleteIrp Length %lu\n", Irp->IoStatus.Information);
 372     DPRINT("HidClass_ReadCompleteIrp Irp %p\n", Irp);
 373     DPRINT("HidClass_ReadCompleteIrp InputReportBuffer %p\n", IrpContext->InputReportBuffer);
 374     DPRINT("HidClass_ReadCompleteIrp InputReportBufferLength %li\n", IrpContext->InputReportBufferLength);
 375     DPRINT("HidClass_ReadCompleteIrp OriginalIrp %p\n", IrpContext->OriginalIrp);
 376
 377     //
 378     // copy result
 379     //
 380     if (Irp->IoStatus.Information)
 381     {
 382         //
 383         // get address
 384         //
 385         Address = MmGetSystemAddressForMdlSafe(IrpContext->OriginalIrp->MdlAddress, NormalPagePriority);
 386         if (Address)
 387         {
 388             //
 389             // reports may have a report id prepended
 390             //
 391             Offset = 0;
 392
 393             //
 394             // get collection description
 395             //
 396             CollectionDescription = HidClassPDO_GetCollectionDescription(&IrpContext->FileOp->DeviceExtension->Common.DeviceDescription,
 397                                                                          IrpContext->FileOp->DeviceExtension->CollectionNumber);
 398             ASSERT(CollectionDescription);
 399
 400             //
 401             // get report description
 402             //
 403             ReportDescription = HidClassPDO_GetReportDescription(&IrpContext->FileOp->DeviceExtension->Common.DeviceDescription,
 404                                                                  IrpContext->FileOp->DeviceExtension->CollectionNumber);
 405             ASSERT(ReportDescription);
 406
 407             if (CollectionDescription && ReportDescription)
 408             {
 409                 //
 410                 // calculate offset
 411                 //
 412                 ASSERT(CollectionDescription->InputLength >= ReportDescription->InputLength);
 413                 Offset = CollectionDescription->InputLength - ReportDescription->InputLength;
 414             }
 415
 416             //
 417             // copy result
 418             //
 419             RtlCopyMemory(&Address[Offset], IrpContext->InputReportBuffer, IrpContext->InputReportBufferLength);
 420         }
 421     }
 422
 423     //
 424     // copy result status
 425     //
 426     IrpContext->OriginalIrp->IoStatus.Status = Irp->IoStatus.Status;
 427     IrpContext->OriginalIrp->IoStatus.Information = Irp->IoStatus.Information;
 428
 429     //
 430     // free input report buffer
 431     //
 432     ExFreePoolWithTag(IrpContext->InputReportBuffer, HIDCLASS_TAG);
 433
 434     //
 435     // remove us from pending list
 436     //
 437     KeAcquireSpinLock(&IrpContext->FileOp->Lock, &OldLevel);
 438
 439     //
 440     // remove from pending list
 441     //
 442     RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
 443
 444     //
 445     // is list empty
 446     //
 447     IsEmpty = IsListEmpty(&IrpContext->FileOp->ReadPendingIrpListHead);
 448
 449     //
 450     // insert into completed list
 451     //
 452     InsertTailList(&IrpContext->FileOp->IrpCompletedListHead, &Irp->Tail.Overlay.ListEntry);
 453
 454     //
 455     // release lock
 456     //
 457     KeReleaseSpinLock(&IrpContext->FileOp->Lock, OldLevel);
 458
 459     //
 460     // complete original request
 461     //
 462     IoCompleteRequest(IrpContext->OriginalIrp, IO_NO_INCREMENT);
 463
 464
 465     DPRINT("StopInProgress %x IsEmpty %x\n", IrpContext->FileOp->StopInProgress, IsEmpty);
 466     if (IrpContext->FileOp->StopInProgress && IsEmpty)
 467     {
 468         //
 469         // last pending irp
 470         //
 471         DPRINT1("[HIDCLASS] LastPendingTransfer Signalling\n");
 472         KeSetEvent(&IrpContext->FileOp->IrpReadComplete, 0, FALSE);
 473     }
 474
 475     if (IrpContext->FileOp->StopInProgress && IsEmpty)
 476     {
 477         //
 478         // last pending irp
 479         //
 480         DPRINT1("[HIDCLASS] LastPendingTransfer Signalling\n");
 481         KeSetEvent(&IrpContext->FileOp->IrpReadComplete, 0, FALSE);
 482     }
 483
 484     //
 485     // free irp context
 486     //
 487     ExFreePoolWithTag(IrpContext, HIDCLASS_TAG);
 488
 489     //
 490     // done
 491     //
 492     return STATUS_MORE_PROCESSING_REQUIRED;
 493 }
 494
 495 PIRP
 496 HidClass_GetIrp(
 497     IN PHIDCLASS_FILEOP_CONTEXT Context)
 498 {
 499    KIRQL OldLevel;
 500    PIRP Irp = NULL;
 501    PLIST_ENTRY ListEntry;
 502
 503     //
 504     // acquire lock
 505     //
 506     KeAcquireSpinLock(&Context->Lock, &OldLevel);
 507
 508     //
 509     // is list empty?
 510     //
 511     if (!IsListEmpty(&Context->IrpCompletedListHead))
 512     {
 513         //
 514         // grab first entry
 515         //
 516         ListEntry = RemoveHeadList(&Context->IrpCompletedListHead);
 517
 518         //
 519         // get irp
 520         //
 521         Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.ListEntry);
 522     }
 523
 524     //
 525     // release lock
 526     //
 527     KeReleaseSpinLock(&Context->Lock, OldLevel);
 528
 529     //
 530     // done
 531     //
 532     return Irp;
 533 }
 534
 535 NTSTATUS
 536 HidClass_BuildIrp(
 537     IN PDEVICE_OBJECT DeviceObject,
 538     IN PIRP RequestIrp,
 539     IN PHIDCLASS_FILEOP_CONTEXT Context,
 540     IN ULONG DeviceIoControlCode,
 541     IN ULONG BufferLength,
 542     OUT PIRP *OutIrp,
 543     OUT PHIDCLASS_IRP_CONTEXT *OutIrpContext)
 544 {
 545     PIRP Irp;
 546     PIO_STACK_LOCATION IoStack;
 547     PHIDCLASS_IRP_CONTEXT IrpContext;
 548     PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
 549     PHIDP_COLLECTION_DESC CollectionDescription;
 550     PHIDP_REPORT_IDS ReportDescription;
 551
 552     //
 553     // get an irp from fresh list
 554     //
 555     Irp = HidClass_GetIrp(Context);
 556     if (!Irp)
 557     {
 558         //
 559         // build new irp
 560         //
 561         Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
 562         if (!Irp)
 563         {
 564             //
 565             // no memory
 566             //
 567             return STATUS_INSUFFICIENT_RESOURCES;
 568         }
 569     }
 570     else
 571     {
 572         //
 573         // re-use irp
 574         //
 575         IoReuseIrp(Irp, STATUS_SUCCESS);
 576     }
 577
 578     //
 579     // allocate completion context
 580     //
 581     IrpContext = ExAllocatePoolWithTag(NonPagedPool, sizeof(HIDCLASS_IRP_CONTEXT), HIDCLASS_TAG);
 582     if (!IrpContext)
 583     {
 584         //
 585         // no memory
 586         //
 587         IoFreeIrp(Irp);
 588         return STATUS_INSUFFICIENT_RESOURCES;
 589     }
 590
 591     //
 592     // get device extension
 593     //
 594     PDODeviceExtension = DeviceObject->DeviceExtension;
 595     ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 596
 597     //
 598     // init irp context
 599     //
 600     RtlZeroMemory(IrpContext, sizeof(HIDCLASS_IRP_CONTEXT));
 601     IrpContext->OriginalIrp = RequestIrp;
 602     IrpContext->FileOp = Context;
 603
 604     //
 605     // get collection description
 606     //
 607     CollectionDescription = HidClassPDO_GetCollectionDescription(&IrpContext->FileOp->DeviceExtension->Common.DeviceDescription,
 608                                                                  IrpContext->FileOp->DeviceExtension->CollectionNumber);
 609     ASSERT(CollectionDescription);
 610
 611     //
 612     // get report description
 613     //
 614     ReportDescription = HidClassPDO_GetReportDescription(&IrpContext->FileOp->DeviceExtension->Common.DeviceDescription,
 615                                                          IrpContext->FileOp->DeviceExtension->CollectionNumber);
 616     ASSERT(ReportDescription);
 617
 618     //
 619     // sanity check
 620     //
 621     ASSERT(CollectionDescription->InputLength >= ReportDescription->InputLength);
 622
 623     if (Context->StopInProgress)
 624     {
 625          //
 626          // stop in progress
 627          //
 628          DPRINT1("[HIDCLASS] Stop In Progress\n");
 629          Irp->IoStatus.Status = STATUS_CANCELLED;
 630          IoCompleteRequest(Irp, IO_NO_INCREMENT);
 631          return STATUS_CANCELLED;
 632
 633     }
 634
 635     //
 636     // store report length
 637     //
 638     IrpContext->InputReportBufferLength = ReportDescription->InputLength;
 639
 640     //
 641     // allocate buffer
 642     //
 643     IrpContext->InputReportBuffer = ExAllocatePoolWithTag(NonPagedPool, IrpContext->InputReportBufferLength, HIDCLASS_TAG);
 644     if (!IrpContext->InputReportBuffer)
 645     {
 646         //
 647         // no memory
 648         //
 649         IoFreeIrp(Irp);
 650         ExFreePoolWithTag(IrpContext, HIDCLASS_TAG);
 651         return STATUS_INSUFFICIENT_RESOURCES;
 652     }
 653
 654     //
 655     // get stack location
 656     //
 657     IoStack = IoGetNextIrpStackLocation(Irp);
 658
 659     //
 660     // init stack location
 661     //
 662     IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
 663     IoStack->Parameters.DeviceIoControl.IoControlCode = DeviceIoControlCode;
 664     IoStack->Parameters.DeviceIoControl.OutputBufferLength = IrpContext->InputReportBufferLength;
 665     IoStack->Parameters.DeviceIoControl.InputBufferLength = 0;
 666     IoStack->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
 667     Irp->UserBuffer = IrpContext->InputReportBuffer;
 668     IoStack->DeviceObject = DeviceObject;
 669
 670     //
 671     // store result
 672     //
 673     *OutIrp = Irp;
 674     *OutIrpContext = IrpContext;
 675
 676     //
 677     // done
 678     //
 679     return STATUS_SUCCESS;
 680 }
 681
 682 NTSTATUS
 683 NTAPI
 684 HidClass_Read(
 685     IN PDEVICE_OBJECT DeviceObject,
 686     IN PIRP Irp)
 687 {
 688     PIO_STACK_LOCATION IoStack;
 689     PHIDCLASS_FILEOP_CONTEXT Context;
 690     KIRQL OldLevel;
 691     NTSTATUS Status;
 692     PIRP NewIrp;
 693     PHIDCLASS_IRP_CONTEXT NewIrpContext;
 694     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
 695
 696     //
 697     // get current stack location
 698     //
 699     IoStack = IoGetCurrentIrpStackLocation(Irp);
 700
 701     //
 702     // get device extension
 703     //
 704     CommonDeviceExtension = DeviceObject->DeviceExtension;
 705     ASSERT(CommonDeviceExtension->IsFDO == FALSE);
 706
 707     //
 708     // sanity check
 709     //
 710     ASSERT(IoStack->FileObject);
 711     ASSERT(IoStack->FileObject->FsContext);
 712
 713     //
 714     // get context
 715     //
 716     Context = IoStack->FileObject->FsContext;
 717     ASSERT(Context);
 718
 719     //
 720     // FIXME support polled devices
 721     //
 722     ASSERT(Context->DeviceExtension->Common.DriverExtension->DevicesArePolled == FALSE);
 723
 724     if (Context->StopInProgress)
 725     {
 726         //
 727         // stop in progress
 728         //
 729         DPRINT1("[HIDCLASS] Stop In Progress\n");
 730         Irp->IoStatus.Status = STATUS_CANCELLED;
 731         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 732         return STATUS_CANCELLED;
 733     }
 734
 735     //
 736     // build irp request
 737     //
 738     Status = HidClass_BuildIrp(DeviceObject,
 739                                Irp,
 740                                Context,
 741                                IOCTL_HID_READ_REPORT,
 742                                IoStack->Parameters.Read.Length,
 743                                &NewIrp,
 744                                &NewIrpContext);
 745     if (!NT_SUCCESS(Status))
 746     {
 747         //
 748         // failed
 749         //
 750         DPRINT1("HidClass_BuildIrp failed with %x\n", Status);
 751         Irp->IoStatus.Status = Status;
 752         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 753         return Status;
 754     }
 755
 756     //
 757     // acquire lock
 758     //
 759     KeAcquireSpinLock(&Context->Lock, &OldLevel);
 760
 761     //
 762     // insert irp into pending list
 763     //
 764     InsertTailList(&Context->ReadPendingIrpListHead, &NewIrp->Tail.Overlay.ListEntry);
 765
 766     //
 767     // set completion routine
 768     //
 769     IoSetCompletionRoutine(NewIrp, HidClass_ReadCompleteIrp, NewIrpContext, TRUE, TRUE, TRUE);
 770
 771     //
 772     // make next location current
 773     //
 774     IoSetNextIrpStackLocation(NewIrp);
 775
 776     //
 777     // release spin lock
 778     //
 779     KeReleaseSpinLock(&Context->Lock, OldLevel);
 780
 781     //
 782     // mark irp pending
 783     //
 784     IoMarkIrpPending(Irp);
 785
 786     //
 787     // let's dispatch the request
 788     //
 789     ASSERT(Context->DeviceExtension);
 790     Status = Context->DeviceExtension->Common.DriverExtension->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL](Context->DeviceExtension->FDODeviceObject, NewIrp);
 791
 792     //
 793     // complete
 794     //
 795     return STATUS_PENDING;
 796 }
 797
 798 NTSTATUS
 799 NTAPI
 800 HidClass_Write(
 801     IN PDEVICE_OBJECT DeviceObject,
 802     IN PIRP Irp)
 803 {
 804     UNIMPLEMENTED;
 805     ASSERT(FALSE);
 806     Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
 807     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 808     return STATUS_NOT_IMPLEMENTED;
 809 }
 810
 811 NTSTATUS
 812 NTAPI
 813 HidClass_DeviceControl(
 814     IN PDEVICE_OBJECT DeviceObject,
 815     IN PIRP Irp)
 816 {
 817     PIO_STACK_LOCATION IoStack;
 818     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
 819     PHID_COLLECTION_INFORMATION CollectionInformation;
 820     PHIDP_COLLECTION_DESC CollectionDescription;
 821     PHIDCLASS_PDO_DEVICE_EXTENSION PDODeviceExtension;
 822
 823     //
 824     // get device extension
 825     //
 826     CommonDeviceExtension = DeviceObject->DeviceExtension;
 827
 828     //
 829     // only PDO are supported
 830     //
 831     if (CommonDeviceExtension->IsFDO)
 832     {
 833         //
 834         // invalid request
 835         //
 836         DPRINT1("[HIDCLASS] DeviceControl Irp for FDO arrived\n");
 837         Irp->IoStatus.Status = STATUS_INVALID_PARAMETER_1;
 838         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 839         return STATUS_INVALID_PARAMETER_1;
 840     }
 841
 842     ASSERT(CommonDeviceExtension->IsFDO == FALSE);
 843
 844     //
 845     // get pdo device extension
 846     //
 847     PDODeviceExtension = DeviceObject->DeviceExtension;
 848
 849     //
 850     // get stack location
 851     //
 852     IoStack = IoGetCurrentIrpStackLocation(Irp);
 853
 854     switch (IoStack->Parameters.DeviceIoControl.IoControlCode)
 855     {
 856         case IOCTL_HID_GET_COLLECTION_INFORMATION:
 857         {
 858             //
 859             // check if output buffer is big enough
 860             //
 861             if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(HID_COLLECTION_INFORMATION))
 862             {
 863                 //
 864                 // invalid buffer size
 865                 //
 866                 Irp->IoStatus.Status = STATUS_INVALID_BUFFER_SIZE;
 867                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 868                 return STATUS_INVALID_BUFFER_SIZE;
 869             }
 870
 871             //
 872             // get output buffer
 873             //
 874             CollectionInformation = Irp->AssociatedIrp.SystemBuffer;
 875             ASSERT(CollectionInformation);
 876
 877             //
 878             // get collection description
 879             //
 880             CollectionDescription = HidClassPDO_GetCollectionDescription(&CommonDeviceExtension->DeviceDescription,
 881                                                                          PDODeviceExtension->CollectionNumber);
 882             ASSERT(CollectionDescription);
 883
 884             //
 885             // init result buffer
 886             //
 887             CollectionInformation->DescriptorSize = CollectionDescription->PreparsedDataLength;
 888             CollectionInformation->Polled = CommonDeviceExtension->DriverExtension->DevicesArePolled;
 889             CollectionInformation->VendorID = CommonDeviceExtension->Attributes.VendorID;
 890             CollectionInformation->ProductID = CommonDeviceExtension->Attributes.ProductID;
 891             CollectionInformation->VersionNumber = CommonDeviceExtension->Attributes.VersionNumber;
 892
 893             //
 894             // complete request
 895             //
 896             Irp->IoStatus.Information = sizeof(HID_COLLECTION_INFORMATION);
 897             Irp->IoStatus.Status = STATUS_SUCCESS;
 898             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 899             return STATUS_SUCCESS;
 900         }
 901         case IOCTL_HID_GET_COLLECTION_DESCRIPTOR:
 902         {
 903             //
 904             // get collection description
 905             //
 906             CollectionDescription = HidClassPDO_GetCollectionDescription(&CommonDeviceExtension->DeviceDescription,
 907                                                                          PDODeviceExtension->CollectionNumber);
 908             ASSERT(CollectionDescription);
 909
 910             //
 911             // check if output buffer is big enough
 912             //
 913             if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < CollectionDescription->PreparsedDataLength)
 914             {
 915                 //
 916                 // invalid buffer size
 917                 //
 918                 Irp->IoStatus.Status = STATUS_INVALID_BUFFER_SIZE;
 919                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 920                 return STATUS_INVALID_BUFFER_SIZE;
 921             }
 922
 923             //
 924             // copy result
 925             //
 926             ASSERT(Irp->UserBuffer);
 927             RtlCopyMemory(Irp->UserBuffer, CollectionDescription->PreparsedData, CollectionDescription->PreparsedDataLength);
 928
 929             //
 930             // complete request
 931             //
 932             Irp->IoStatus.Information = CollectionDescription->PreparsedDataLength;
 933             Irp->IoStatus.Status = STATUS_SUCCESS;
 934             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 935             return STATUS_SUCCESS;
 936         }
 937         default:
 938         {
 939             DPRINT1("[HIDCLASS] DeviceControl IoControlCode 0x%x not implemented\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
 940             Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
 941             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 942             return STATUS_NOT_IMPLEMENTED;
 943         }
 944     }
 945 }
 946
 947 NTSTATUS
 948 NTAPI
 949 HidClass_InternalDeviceControl(
 950     IN PDEVICE_OBJECT DeviceObject,
 951     IN PIRP Irp)
 952 {
 953     UNIMPLEMENTED;
 954     ASSERT(FALSE);
 955     Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
 956     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 957     return STATUS_NOT_IMPLEMENTED;
 958 }
 959
 960 NTSTATUS
 961 NTAPI
 962 HidClass_Power(
 963     IN PDEVICE_OBJECT DeviceObject,
 964     IN PIRP Irp)
 965 {
 966     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
 967     CommonDeviceExtension = DeviceObject->DeviceExtension;
 968
 969     if (CommonDeviceExtension->IsFDO)
 970     {
 971         IoCopyCurrentIrpStackLocationToNext(Irp);
 972         return HidClassFDO_DispatchRequest(DeviceObject, Irp);
 973     }
 974     else
 975     {
 976         Irp->IoStatus.Status = STATUS_SUCCESS;
 977         PoStartNextPowerIrp(Irp);
 978         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 979         return STATUS_SUCCESS;
 980     }
 981 }
 982
 983 NTSTATUS
 984 NTAPI
 985 HidClass_PnP(
 986     IN PDEVICE_OBJECT DeviceObject,
 987     IN PIRP Irp)
 988 {
 989     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
 990
 991     //
 992     // get common device extension
 993     //
 994     CommonDeviceExtension = DeviceObject->DeviceExtension;
 995
 996     //
 997     // check type of device object
 998     //
 999     if (CommonDeviceExtension->IsFDO)
1000     {
1001         //
1002         // handle request
1003         //
1004         return HidClassFDO_PnP(DeviceObject, Irp);
1005     }
1006     else
1007     {
1008         //
1009         // handle request
1010         //
1011         return HidClassPDO_PnP(DeviceObject, Irp);
1012     }
1013 }
1014
1015 NTSTATUS
1016 NTAPI
1017 HidClass_DispatchDefault(
1018     IN PDEVICE_OBJECT DeviceObject,
1019     IN PIRP Irp)
1020 {
1021     PHIDCLASS_COMMON_DEVICE_EXTENSION CommonDeviceExtension;
1022
1023     //
1024     // get common device extension
1025     //
1026     CommonDeviceExtension = DeviceObject->DeviceExtension;
1027
1028     //
1029     // FIXME: support PDO
1030     //
1031     ASSERT(CommonDeviceExtension->IsFDO == TRUE);
1032
1033     //
1034     // skip current irp stack location
1035     //
1036     IoSkipCurrentIrpStackLocation(Irp);
1037
1038     //
1039     // dispatch to lower device object
1040     //
1041     return IoCallDriver(CommonDeviceExtension->HidDeviceExtension.NextDeviceObject, Irp);
1042 }
1043
1044 NTSTATUS
1045 NTAPI
1046 HidClassDispatch(
1047     IN PDEVICE_OBJECT DeviceObject,
1048     IN PIRP Irp)
1049 {
1050     PIO_STACK_LOCATION IoStack;
1051
1052     //
1053     // get current stack location
1054     //
1055     IoStack = IoGetCurrentIrpStackLocation(Irp);
1056     DPRINT("[HIDCLASS] Dispatch Major %x Minor %x\n", IoStack->MajorFunction, IoStack->MinorFunction);
1057
1058     //
1059     // dispatch request based on major function
1060     //
1061     switch (IoStack->MajorFunction)
1062     {
1063         case IRP_MJ_CREATE:
1064             return HidClass_Create(DeviceObject, Irp);
1065         case IRP_MJ_CLOSE:
1066             return HidClass_Close(DeviceObject, Irp);
1067         case IRP_MJ_READ:
1068             return HidClass_Read(DeviceObject, Irp);
1069         case IRP_MJ_WRITE:
1070             return HidClass_Write(DeviceObject, Irp);
1071         case IRP_MJ_DEVICE_CONTROL:
1072             return HidClass_DeviceControl(DeviceObject, Irp);
1073         case IRP_MJ_INTERNAL_DEVICE_CONTROL:
1074            return HidClass_InternalDeviceControl(DeviceObject, Irp);
1075         case IRP_MJ_POWER:
1076             return HidClass_Power(DeviceObject, Irp);
1077         case IRP_MJ_PNP:
1078             return HidClass_PnP(DeviceObject, Irp);
1079         default:
1080             return HidClass_DispatchDefault(DeviceObject, Irp);
1081     }
1082 }
1083
1084 NTSTATUS
1085 NTAPI
1086 HidRegisterMinidriver(
1087     IN PHID_MINIDRIVER_REGISTRATION MinidriverRegistration)
1088 {
1089     NTSTATUS Status;
1090     PHIDCLASS_DRIVER_EXTENSION DriverExtension;
1091
1092     /* check if the version matches */
1093     if (MinidriverRegistration->Revision > HID_REVISION)
1094     {
1095         /* revision mismatch */
1096         ASSERT(FALSE);
1097         return STATUS_REVISION_MISMATCH;
1098     }
1099
1100     /* now allocate the driver object extension */
1101     Status = IoAllocateDriverObjectExtension(MinidriverRegistration->DriverObject,
1102                                              ClientIdentificationAddress,
1103                                              sizeof(HIDCLASS_DRIVER_EXTENSION),
1104                                              (PVOID *)&DriverExtension);
1105     if (!NT_SUCCESS(Status))
1106     {
1107         /* failed to allocate driver extension */
1108         ASSERT(FALSE);
1109         return Status;
1110     }
1111
1112     /* zero driver extension */
1113     RtlZeroMemory(DriverExtension, sizeof(HIDCLASS_DRIVER_EXTENSION));
1114
1115     /* init driver extension */
1116     DriverExtension->DriverObject = MinidriverRegistration->DriverObject;
1117     DriverExtension->DeviceExtensionSize = MinidriverRegistration->DeviceExtensionSize;
1118     DriverExtension->DevicesArePolled = MinidriverRegistration->DevicesArePolled;
1119     DriverExtension->AddDevice = MinidriverRegistration->DriverObject->DriverExtension->AddDevice;
1120     DriverExtension->DriverUnload = MinidriverRegistration->DriverObject->DriverUnload;
1121
1122     /* copy driver dispatch routines */
1123     RtlCopyMemory(DriverExtension->MajorFunction,
1124                   MinidriverRegistration->DriverObject->MajorFunction,
1125                   sizeof(PDRIVER_DISPATCH) * (IRP_MJ_MAXIMUM_FUNCTION + 1));
1126
1127     /* initialize lock */
1128     KeInitializeSpinLock(&DriverExtension->Lock);
1129
1130     /* now replace dispatch routines */
1131     DriverExtension->DriverObject->DriverExtension->AddDevice = HidClassAddDevice;
1132     DriverExtension->DriverObject->DriverUnload = HidClassDriverUnload;
1133     DriverExtension->DriverObject->MajorFunction[IRP_MJ_CREATE] = HidClassDispatch;
1134     DriverExtension->DriverObject->MajorFunction[IRP_MJ_CLOSE] = HidClassDispatch;
1135     DriverExtension->DriverObject->MajorFunction[IRP_MJ_READ] = HidClassDispatch;
1136     DriverExtension->DriverObject->MajorFunction[IRP_MJ_WRITE] = HidClassDispatch;
1137     DriverExtension->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = HidClassDispatch;
1138     DriverExtension->DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = HidClassDispatch;
1139     DriverExtension->DriverObject->MajorFunction[IRP_MJ_POWER] = HidClassDispatch;
1140     DriverExtension->DriverObject->MajorFunction[IRP_MJ_PNP] = HidClassDispatch;
1141
1142     /* done */
1143     return STATUS_SUCCESS;
1144 }