ReactOS  0.4.15-dev-5459-gb85f005
fdo.c File Reference
#include "usbccgp.h"
#include <debug.h>
Include dependency graph for fdo.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

NTSTATUS NTAPI FDO_QueryCapabilitiesCompletionRoutine (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
 
NTSTATUS FDO_QueryCapabilities (IN PDEVICE_OBJECT DeviceObject, IN OUT PDEVICE_CAPABILITIES Capabilities)
 
NTSTATUS FDO_DeviceRelations (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS FDO_CreateChildPdo (IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS FDO_StartDevice (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS FDO_CloseConfiguration (IN PDEVICE_OBJECT DeviceObject)
 
NTSTATUS FDO_HandlePnp (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS FDO_HandleResetCyclePort (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS FDO_HandleInternalDeviceControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS FDO_HandleSystemControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS FDO_Dispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 14 of file fdo.c.

Function Documentation

◆ FDO_CloseConfiguration()

NTSTATUS FDO_CloseConfiguration ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 338 of file fdo.c.

340 {
342  PURB Urb;
343  PFDO_DEVICE_EXTENSION FDODeviceExtension;
344 
345  /* Get device extension */
346  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
347  ASSERT(FDODeviceExtension->Common.IsFDO);
348 
349  /* Nothing to do if we're not configured */
350  if (FDODeviceExtension->ConfigurationDescriptor == NULL ||
351  FDODeviceExtension->InterfaceList == NULL)
352  {
353  return STATUS_SUCCESS;
354  }
355 
356  /* Now allocate the urb */
357  Urb = USBD_CreateConfigurationRequestEx(FDODeviceExtension->ConfigurationDescriptor,
358  FDODeviceExtension->InterfaceList);
359  if (!Urb)
360  {
361  /* No memory */
363  }
364 
365  /* Clear configuration descriptor to make it an unconfigure request */
366  Urb->UrbSelectConfiguration.ConfigurationDescriptor = NULL;
367 
368  /* Submit urb */
369  Status = USBCCGP_SyncUrbRequest(FDODeviceExtension->NextDeviceObject, Urb);
370  if (!NT_SUCCESS(Status))
371  {
372  /* Failed to set configuration */
373  DPRINT1("USBCCGP_SyncUrbRequest failed to unconfigure device\n", Status);
374  }
375 
376  ExFreePool(Urb);
377  return Status;
378 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
LONG NTSTATUS
Definition: precomp.h:26
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
struct _URB_SELECT_CONFIGURATION UrbSelectConfiguration
Definition: usb.h:533
Definition: usb.h:529
NTSTATUS USBCCGP_SyncUrbRequest(IN PDEVICE_OBJECT DeviceObject, OUT PURB UrbRequest)
Definition: misc.c:35
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
#define STATUS_SUCCESS
Definition: shellext.h:65
PURB NTAPI USBD_CreateConfigurationRequestEx(PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, PUSBD_INTERFACE_LIST_ENTRY InterfaceList)
Definition: usbd.c:329
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

Referenced by FDO_HandlePnp().

◆ FDO_CreateChildPdo()

NTSTATUS FDO_CreateChildPdo ( IN PDEVICE_OBJECT  DeviceObject)

Definition at line 169 of file fdo.c.

171 {
173  PDEVICE_OBJECT PDODeviceObject;
174  PPDO_DEVICE_EXTENSION PDODeviceExtension;
175  PFDO_DEVICE_EXTENSION FDODeviceExtension;
176  ULONG Index;
177 
178  /* Get device extension */
179  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
180  ASSERT(FDODeviceExtension->Common.IsFDO);
181 
182  /* Lets create array for the child PDO */
183  FDODeviceExtension->ChildPDO = AllocateItem(NonPagedPool,
184  sizeof(PDEVICE_OBJECT) * FDODeviceExtension->FunctionDescriptorCount);
185  if (!FDODeviceExtension->ChildPDO)
186  {
187  /* No memory */
189  }
190 
191  /* Create pdo for each function */
192  for(Index = 0; Index < FDODeviceExtension->FunctionDescriptorCount; Index++)
193  {
194  /* Create the PDO */
195  Status = IoCreateDevice(FDODeviceExtension->DriverObject,
196  sizeof(PDO_DEVICE_EXTENSION),
197  NULL,
200  FALSE,
201  &PDODeviceObject);
202  if (!NT_SUCCESS(Status))
203  {
204  /* Failed to create device object */
205  DPRINT1("IoCreateDevice failed with %x\n", Status);
206  return Status;
207  }
208 
209  /* Store in array */
210  FDODeviceExtension->ChildPDO[Index] = PDODeviceObject;
211 
212  /* Get device extension */
213  PDODeviceExtension = (PPDO_DEVICE_EXTENSION)PDODeviceObject->DeviceExtension;
214  RtlZeroMemory(PDODeviceExtension, sizeof(PDO_DEVICE_EXTENSION));
215 
216  /* Init device extension */
217  PDODeviceExtension->Common.IsFDO = FALSE;
218  PDODeviceExtension->FunctionDescriptor = &FDODeviceExtension->FunctionDescriptor[Index];
219  PDODeviceExtension->NextDeviceObject = DeviceObject;
220  PDODeviceExtension->FunctionIndex = Index;
221  PDODeviceExtension->FDODeviceExtension = FDODeviceExtension;
222  PDODeviceExtension->InterfaceList = FDODeviceExtension->InterfaceList;
223  PDODeviceExtension->InterfaceListCount = FDODeviceExtension->InterfaceListCount;
224  PDODeviceExtension->ConfigurationHandle = FDODeviceExtension->ConfigurationHandle;
225  PDODeviceExtension->ConfigurationDescriptor = FDODeviceExtension->ConfigurationDescriptor;
226  RtlCopyMemory(&PDODeviceExtension->Capabilities, &FDODeviceExtension->Capabilities, sizeof(DEVICE_CAPABILITIES));
227  RtlCopyMemory(&PDODeviceExtension->DeviceDescriptor, FDODeviceExtension->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
228 
229  /* Patch the stack size */
230  PDODeviceObject->StackSize = DeviceObject->StackSize + 1;
231 
232  /* Set device flags */
233  PDODeviceObject->Flags |= DO_DIRECT_IO | DO_MAP_IO_BUFFER;
234 
235  /* Device is initialized */
236  PDODeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
237  }
238 
239  /* Done */
240  return STATUS_SUCCESS;
241 }
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:30
#define FILE_DEVICE_USB
Definition: usbiodef.h:71
LONG NTSTATUS
Definition: precomp.h:26
struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION
DEVICE_CAPABILITIES
Definition: iotypes.h:965
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
#define DO_DIRECT_IO
Definition: env_spec_w32.h:396
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
PVOID DeviceExtension
Definition: env_spec_w32.h:418
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:59
#define FILE_AUTOGENERATED_DEVICE_NAME
Definition: iotypes.h:138
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ WDFCOLLECTION _In_ ULONG Index
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
unsigned int ULONG
Definition: retypes.h:1
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DO_MAP_IO_BUFFER
Definition: env_spec_w32.h:397

Referenced by FDO_StartDevice().

◆ FDO_DeviceRelations()

NTSTATUS FDO_DeviceRelations ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 102 of file fdo.c.

105 {
106  ULONG DeviceCount = 0;
107  ULONG Index;
108  PDEVICE_RELATIONS DeviceRelations;
109  PIO_STACK_LOCATION IoStack;
110  PFDO_DEVICE_EXTENSION FDODeviceExtension;
111 
112  /* Get device extension */
113  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
114 
115  /* Get current irp stack location */
117 
118  /* Check if relation type is BusRelations */
119  if (IoStack->Parameters.QueryDeviceRelations.Type != BusRelations)
120  {
121  /* FDO always only handles bus relations */
122  return STATUS_SUCCESS;
123  }
124 
125  /* Go through array and count device objects */
126  for(Index = 0; Index < FDODeviceExtension->FunctionDescriptorCount; Index++)
127  {
128  if (FDODeviceExtension->ChildPDO[Index])
129  {
130  /* Child pdo */
131  DeviceCount++;
132  }
133  }
134 
135  /* Allocate device relations */
136  DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(PagedPool,
137  sizeof(DEVICE_RELATIONS) + (DeviceCount > 1 ? (DeviceCount-1) * sizeof(PDEVICE_OBJECT) : 0));
138  if (!DeviceRelations)
139  {
140  /* No memory */
142  }
143 
144  /* Add device objects */
145  for(Index = 0; Index < FDODeviceExtension->FunctionDescriptorCount; Index++)
146  {
147  if (FDODeviceExtension->ChildPDO[Index])
148  {
149  /* Store child pdo */
150  DeviceRelations->Objects[DeviceRelations->Count] = FDODeviceExtension->ChildPDO[Index];
151 
152  /* Add reference */
153  ObReferenceObject(FDODeviceExtension->ChildPDO[Index]);
154 
155  /* Increment count */
156  DeviceRelations->Count++;
157  }
158  }
159 
160  /* Store result */
161  Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
162  Irp->IoStatus.Status = STATUS_SUCCESS;
163 
164  /* Request completed successfully */
165  return STATUS_SUCCESS;
166 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2163
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:30
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
ULONG DeviceCount
Definition: mpu401.c:26
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
_In_ WDFCOLLECTION _In_ ULONG Index
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define ObReferenceObject
Definition: obfuncs.h:204
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128

Referenced by FDO_HandlePnp().

◆ FDO_Dispatch()

NTSTATUS FDO_Dispatch ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 633 of file fdo.c.

636 {
637  PIO_STACK_LOCATION IoStack;
639  PFDO_DEVICE_EXTENSION FDODeviceExtension;
640 
641  /* Get device extension */
642  FDODeviceExtension = DeviceObject->DeviceExtension;
643  ASSERT(FDODeviceExtension->Common.IsFDO);
644 
645  /* Get stack location */
647 
648  switch(IoStack->MajorFunction)
649  {
650  case IRP_MJ_PNP:
651  return FDO_HandlePnp(DeviceObject, Irp);
654  case IRP_MJ_POWER:
657  return PoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
660  default:
661  DPRINT1("FDO_Dispatch Function %x not implemented\n", IoStack->MajorFunction);
662  ASSERT(FALSE);
663  Status = Irp->IoStatus.Status;
665  return Status;
666  }
667 
668 }
NTSTATUS FDO_HandleInternalDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: fdo.c:581
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
LONG NTSTATUS
Definition: precomp.h:26
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define IoCompleteRequest
Definition: irp.c:1240
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define IRP_MJ_INTERNAL_DEVICE_CONTROL
#define IRP_MJ_POWER
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
#define IRP_MJ_SYSTEM_CONTROL
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
VOID NTAPI PoStartNextPowerIrp(IN PIRP Irp)
Definition: power.c:746
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
#define DPRINT1
Definition: precomp.h:8
NTSTATUS FDO_HandlePnp(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: fdo.c:382
#define IO_NO_INCREMENT
Definition: iotypes.h:598
NTSTATUS FDO_HandleSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: fdo.c:617

Referenced by USBCCGP_Dispatch().

◆ FDO_HandleInternalDeviceControl()

NTSTATUS FDO_HandleInternalDeviceControl ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 581 of file fdo.c.

584 {
585  PIO_STACK_LOCATION IoStack;
587  PFDO_DEVICE_EXTENSION FDODeviceExtension;
588 
589  /* Get device extension */
590  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
591  ASSERT(FDODeviceExtension->Common.IsFDO);
592 
593  /* Get stack location */
595 
596  if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_RESET_PORT ||
597  IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_CYCLE_PORT)
598  {
599  /* Handle reset / cycle ports */
601  DPRINT("FDO_HandleResetCyclePort Status %x\n", Status);
602  if (Status != STATUS_PENDING)
603  {
604  /* Complete request */
605  Irp->IoStatus.Status = Status;
607  }
608  return Status;
609  }
610 
611  /* Forward and forget request */
613  return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
614 }
LONG NTSTATUS
Definition: precomp.h:26
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
#define IoCompleteRequest
Definition: irp.c:1240
#define IOCTL_INTERNAL_USB_CYCLE_PORT
Definition: usbioctl.h:53
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define STATUS_PENDING
Definition: ntstatus.h:82
NTSTATUS FDO_HandleResetCyclePort(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: fdo.c:483
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
#define IOCTL_INTERNAL_USB_RESET_PORT
Definition: usbioctl.h:35
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define DPRINT
Definition: sndvol32.h:71
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128

Referenced by FDO_Dispatch().

◆ FDO_HandlePnp()

NTSTATUS FDO_HandlePnp ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 382 of file fdo.c.

385 {
386  PIO_STACK_LOCATION IoStack;
388  PFDO_DEVICE_EXTENSION FDODeviceExtension;
389 
390  /* Get device extension */
391  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
392  ASSERT(FDODeviceExtension->Common.IsFDO);
393 
394 
395  /* Get stack location */
397  DPRINT("[USBCCGP] PnP Minor %x\n", IoStack->MinorFunction);
398  switch(IoStack->MinorFunction)
399  {
401  {
402  // Unconfigure device */
403  DPRINT1("[USBCCGP] FDO IRP_MN_REMOVE\n");
405 
406  /* Send the IRP down the stack */
407  Irp->IoStatus.Status = STATUS_SUCCESS;
409  Status = IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
410 
411  /* Detach from the device stack */
412  IoDetachDevice(FDODeviceExtension->NextDeviceObject);
413 
414  /* Delete the device object */
416 
417  /* Request completed */
418  break;
419  }
420  case IRP_MN_START_DEVICE:
421  {
422  /* Start the device */
424  break;
425  }
427  {
428  /* Handle device relations */
430  if (!NT_SUCCESS(Status))
431  {
432  break;
433  }
434 
435  /* Forward irp to next device object */
437  return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
438  }
440  {
441  /* Copy capabilities */
442  RtlCopyMemory(IoStack->Parameters.DeviceCapabilities.Capabilities,
443  &FDODeviceExtension->Capabilities,
444  sizeof(DEVICE_CAPABILITIES));
446 
447  if (IoForwardIrpSynchronously(FDODeviceExtension->NextDeviceObject, Irp))
448  {
449  Status = Irp->IoStatus.Status;
450  if (NT_SUCCESS(Status))
451  {
452  IoStack->Parameters.DeviceCapabilities.Capabilities->SurpriseRemovalOK = TRUE;
453  }
454  }
455  break;
456  }
459  {
460  /* Sure */
461  Irp->IoStatus.Status = STATUS_SUCCESS;
462 
463  /* Forward irp to next device object */
465  return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
466  }
467  default:
468  {
469  /* Forward irp to next device object */
471  return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
472  }
473 
474  }
475 
476  /* Complete request */
477  Irp->IoStatus.Status = Status;
479  return Status;
480 }
#define IRP_MN_REMOVE_DEVICE
NTSTATUS FDO_CloseConfiguration(IN PDEVICE_OBJECT DeviceObject)
Definition: fdo.c:338
#define TRUE
Definition: types.h:120
BOOLEAN NTAPI IoForwardIrpSynchronously(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1625
LONG NTSTATUS
Definition: precomp.h:26
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1296
DEVICE_CAPABILITIES
Definition: iotypes.h:965
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
#define IRP_MN_QUERY_REMOVE_DEVICE
#define IoCompleteRequest
Definition: irp.c:1240
#define IRP_MN_QUERY_STOP_DEVICE
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define IRP_MN_START_DEVICE
NTSTATUS FDO_DeviceRelations(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: fdo.c:102
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
NTSTATUS FDO_StartDevice(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: fdo.c:244
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IRP_MN_QUERY_DEVICE_RELATIONS
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
#define DPRINT1
Definition: precomp.h:8
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
#define IRP_MN_QUERY_CAPABILITIES

Referenced by FDO_Dispatch().

◆ FDO_HandleResetCyclePort()

NTSTATUS FDO_HandleResetCyclePort ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 483 of file fdo.c.

486 {
487  PIO_STACK_LOCATION IoStack;
489  PFDO_DEVICE_EXTENSION FDODeviceExtension;
490  PLIST_ENTRY ListHead, Entry;
491  LIST_ENTRY TempList;
492  PUCHAR ResetActive;
493  PIRP ListIrp;
494  KIRQL OldLevel;
495 
496  /* Get device extension */
497  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
498  ASSERT(FDODeviceExtension->Common.IsFDO);
499 
500  /* Get stack location */
502  DPRINT("FDO_HandleResetCyclePort IOCTL %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
503 
504  if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_RESET_PORT)
505  {
506  /* Use reset port list */
507  ListHead = &FDODeviceExtension->ResetPortListHead;
508  ResetActive = &FDODeviceExtension->ResetPortActive;
509  }
510  else
511  {
512  /* Use cycle port list */
513  ListHead = &FDODeviceExtension->CyclePortListHead;
514  ResetActive = &FDODeviceExtension->CyclePortActive;
515  }
516 
517  /* Acquire lock */
518  KeAcquireSpinLock(&FDODeviceExtension->Lock, &OldLevel);
519 
520  if (*ResetActive)
521  {
522  /* Insert into pending list */
523  InsertTailList(ListHead, &Irp->Tail.Overlay.ListEntry);
524 
525  /* Mark irp pending */
528 
529  /* Release lock */
530  KeReleaseSpinLock(&FDODeviceExtension->Lock, OldLevel);
531  }
532  else
533  {
534  /* Mark reset active */
535  *ResetActive = TRUE;
536 
537  /* Release lock */
538  KeReleaseSpinLock(&FDODeviceExtension->Lock, OldLevel);
539 
540  /* Forward request synchronized */
541  NT_VERIFY(IoForwardIrpSynchronously(FDODeviceExtension->NextDeviceObject, Irp));
542 
543  /* Reacquire lock */
544  KeAcquireSpinLock(&FDODeviceExtension->Lock, &OldLevel);
545 
546  /* Mark reset as completed */
547  *ResetActive = FALSE;
548 
549  /* Move all requests into temporary list */
550  InitializeListHead(&TempList);
551  while(!IsListEmpty(ListHead))
552  {
553  Entry = RemoveHeadList(ListHead);
554  InsertTailList(&TempList, Entry);
555  }
556 
557  /* Release lock */
558  KeReleaseSpinLock(&FDODeviceExtension->Lock, OldLevel);
559 
560  /* Complete pending irps */
561  while(!IsListEmpty(&TempList))
562  {
563  Entry = RemoveHeadList(&TempList);
564  ListIrp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
565 
566  /* Complete request with status success */
567  ListIrp->IoStatus.Status = STATUS_SUCCESS;
569  }
570 
571  /* Status success */
573  }
574 
575  return Status;
576 }
struct _Entry Entry
Definition: kefuncs.h:629
#define TRUE
Definition: types.h:120
BOOLEAN NTAPI IoForwardIrpSynchronously(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1625
unsigned char * PUCHAR
Definition: retypes.h:3
LONG NTSTATUS
Definition: precomp.h:26
VOID NTAPI KeAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL OldIrql)
Definition: spinlock.c:50
IO_STATUS_BLOCK IoStatus
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3287
#define InsertTailList(ListHead, Entry)
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
UCHAR KIRQL
Definition: env_spec_w32.h:591
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
#define IoCompleteRequest
Definition: irp.c:1240
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define STATUS_PENDING
Definition: ntstatus.h:82
struct _IRP * PIRP
Definition: typedefs.h:119
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2793
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define IOCTL_INTERNAL_USB_RESET_PORT
Definition: usbioctl.h:35
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
IoMarkIrpPending(Irp)
base of all file and directory entries
Definition: entries.h:82

Referenced by FDO_HandleInternalDeviceControl().

◆ FDO_HandleSystemControl()

NTSTATUS FDO_HandleSystemControl ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 617 of file fdo.c.

620 {
621  PFDO_DEVICE_EXTENSION FDODeviceExtension;
622 
623  /* Get device extension */
624  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
625  ASSERT(FDODeviceExtension->Common.IsFDO);
626 
627  /* Forward and forget request */
629  return IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
630 }
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
#define ASSERT(a)
Definition: mode.c:44
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421

Referenced by FDO_Dispatch().

◆ FDO_QueryCapabilities()

NTSTATUS FDO_QueryCapabilities ( IN PDEVICE_OBJECT  DeviceObject,
IN OUT PDEVICE_CAPABILITIES  Capabilities 
)

Definition at line 32 of file fdo.c.

35 {
36  PIRP Irp;
37  KEVENT Event;
39  PIO_STACK_LOCATION IoStack;
40  PFDO_DEVICE_EXTENSION FDODeviceExtension;
41 
42  /* Get device extension */
43  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
44  ASSERT(FDODeviceExtension->Common.IsFDO);
45 
46  /* Init event */
48 
49  /* Now allocate the irp */
50  Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
51  if (!Irp)
52  {
53  /* No memory */
55  }
56 
57  /* Get next stack location */
58  IoStack = IoGetNextIrpStackLocation(Irp);
59 
60  /* Init stack location */
61  IoStack->MajorFunction = IRP_MJ_PNP;
63  IoStack->Parameters.DeviceCapabilities.Capabilities = Capabilities;
64 
65  /* Set completion routine */
68  (PVOID)&Event,
69  TRUE,
70  TRUE,
71  TRUE);
72 
73  /* Init capabilities */
75  Capabilities->Size = sizeof(DEVICE_CAPABILITIES);
76  Capabilities->Version = 1; // FIXME hardcoded constant
77  Capabilities->Address = MAXULONG;
78  Capabilities->UINumber = MAXULONG;
79 
80  /* Pnp irps have default completion code */
81  Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
82 
83  /* Call lower device */
84  Status = IoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
85  if (Status == STATUS_PENDING)
86  {
87  /* Wait for completion */
89  }
90 
91  /* Get status */
92  Status = Irp->IoStatus.Status;
93 
94  /* Complete request */
95  IoFreeIrp(Irp);
96 
97  /* Done */
98  return Status;
99 }
return STATUS_NOT_SUPPORTED
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define TRUE
Definition: types.h:120
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
LONG NTSTATUS
Definition: precomp.h:26
DEVICE_CAPABILITIES
Definition: iotypes.h:965
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:498
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FALSE
Definition: types.h:117
_In_ PIRP Irp
Definition: csq.h:116
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103
NTSTATUS NTAPI FDO_QueryCapabilitiesCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
Definition: fdo.c:19
_In_ PVOID _In_ ULONG Event
Definition: iotypes.h:467
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define STATUS_PENDING
Definition: ntstatus.h:82
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
#define MAXULONG
Definition: typedefs.h:251
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
PIRP NTAPI IoAllocateIrp(IN CCHAR StackSize, IN BOOLEAN ChargeQuota)
Definition: irp.c:615
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3128
#define IRP_MN_QUERY_CAPABILITIES

Referenced by FDO_StartDevice().

◆ FDO_QueryCapabilitiesCompletionRoutine()

NTSTATUS NTAPI FDO_QueryCapabilitiesCompletionRoutine ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PVOID  Context 
)

Definition at line 19 of file fdo.c.

23 {
24  /* Set event */
26 
27  /* Completion is done in the HidClassFDO_QueryCapabilities routine */
29 }
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
#define FALSE
Definition: types.h:117

Referenced by FDO_QueryCapabilities().

◆ FDO_StartDevice()

NTSTATUS FDO_StartDevice ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Definition at line 244 of file fdo.c.

247 {
249  PFDO_DEVICE_EXTENSION FDODeviceExtension;
250 
251  /* Get device extension */
252  FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
253  ASSERT(FDODeviceExtension->Common.IsFDO);
254 
255  /* First start lower device */
256  if (IoForwardIrpSynchronously(FDODeviceExtension->NextDeviceObject, Irp))
257  {
258  Status = Irp->IoStatus.Status;
259  }
260  else
261  {
263  }
264 
265  if (!NT_SUCCESS(Status))
266  {
267  /* Failed to start lower device */
268  DPRINT1("FDO_StartDevice lower device failed to start with %x\n", Status);
269  return Status;
270  }
271 
272  /* Get descriptors */
274  if (!NT_SUCCESS(Status))
275  {
276  /* Failed to start lower device */
277  DPRINT1("FDO_StartDevice failed to get descriptors with %x\n", Status);
278  return Status;
279  }
280 
281  /* Get capabilities */
283  &FDODeviceExtension->Capabilities);
284  if (!NT_SUCCESS(Status))
285  {
286  /* Failed to start lower device */
287  DPRINT1("FDO_StartDevice failed to get capabilities with %x\n", Status);
288  return Status;
289  }
290 
291  /* Now select the configuration */
292  Status = USBCCGP_SelectConfiguration(DeviceObject, FDODeviceExtension);
293  if (!NT_SUCCESS(Status))
294  {
295  /* Failed to select interface */
296  DPRINT1("FDO_StartDevice failed to get capabilities with %x\n", Status);
297  return Status;
298  }
299 
300  /* Query bus interface */
301  USBCCGP_QueryInterface(FDODeviceExtension->NextDeviceObject,
302  &FDODeviceExtension->BusInterface);
303 
304  /* Now enumerate the functions */
306  if (!NT_SUCCESS(Status))
307  {
308  /* Failed to enumerate functions */
309  DPRINT1("Failed to enumerate functions with %x\n", Status);
310  return Status;
311  }
312 
313  /* Sanity checks */
314  ASSERT(FDODeviceExtension->FunctionDescriptorCount);
315  ASSERT(FDODeviceExtension->FunctionDescriptor);
316  DumpFunctionDescriptor(FDODeviceExtension->FunctionDescriptor,
317  FDODeviceExtension->FunctionDescriptorCount);
318 
319  /* Now create the pdo */
321  if (!NT_SUCCESS(Status))
322  {
323  /* Failed */
324  DPRINT1("FDO_CreateChildPdo failed with %x\n", Status);
325  return Status;
326  }
327 
328  /* Inform pnp manager of new device objects */
329  IoInvalidateDeviceRelations(FDODeviceExtension->PhysicalDeviceObject,
330  BusRelations);
331 
332  /* Done */
333  DPRINT("[USBCCGP] FDO initialized successfully\n");
334  return Status;
335 }
NTSTATUS USBCCGP_EnumerateFunctions(IN PDEVICE_OBJECT DeviceObject)
Definition: function.c:829
PBUS_INTERFACE_STANDARD BusInterface
Definition: pciidex.h:23
BOOLEAN NTAPI IoForwardIrpSynchronously(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1625
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS USBCCGP_SelectConfiguration(IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
Definition: descriptor.c:467
struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ PIRP Irp
Definition: csq.h:116
NTSTATUS FDO_CreateChildPdo(IN PDEVICE_OBJECT DeviceObject)
Definition: fdo.c:169
Status
Definition: gdiplustypes.h:24
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
NTSTATUS USBCCGP_GetDescriptors(IN PDEVICE_OBJECT DeviceObject)
Definition: descriptor.c:160
VOID DumpFunctionDescriptor(IN PUSBC_FUNCTION_DESCRIPTOR FunctionDescriptor, IN ULONG FunctionDescriptorCount)
Definition: misc.c:120
COMMON_DEVICE_EXTENSION Common
Definition: pci.h:84
NTSTATUS USBCCGP_QueryInterface(IN PDEVICE_OBJECT DeviceObject, OUT PUSBC_DEVICE_CONFIGURATION_INTERFACE_V1 BusInterface)
Definition: function.c:18
VOID NTAPI IoInvalidateDeviceRelations(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_RELATION_TYPE Type)
Definition: pnpmgr.c:2342
#define DPRINT1
Definition: precomp.h:8
#define DPRINT
Definition: sndvol32.h:71
NTSTATUS FDO_QueryCapabilities(IN PDEVICE_OBJECT DeviceObject, IN OUT PDEVICE_CAPABILITIES Capabilities)
Definition: fdo.c:32

Referenced by FDO_HandlePnp().