xref: /reactos/drivers/usb/usbstor/fdo.c (revision d7fd62d4) 
1 /*
2  * PROJECT:     ReactOS Universal Serial Bus Bulk Storage Driver
3  * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4  * PURPOSE:     USB block storage device driver.
5  * COPYRIGHT:   2005-2006 James Tabor
6  *              2011-2012 Michael Martin (michael.martin@reactos.org)
7  *              2011-2013 Johannes Anderwald (johannes.anderwald@reactos.org)
8  *              2019 Victor Perevertkin (victor.perevertkin@reactos.org)
9  */
10 
11 #include "usbstor.h"
12 
13 #define NDEBUG
14 #include <debug.h>
15 
16 
17 #if DBG
18 static
19 VOID
20 USBSTOR_DumpDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor)
21 {
22     DPRINT("Dumping Device Descriptor %p\n", DeviceDescriptor);
23     DPRINT("bLength %x\n", DeviceDescriptor->bLength);
24     DPRINT("bDescriptorType %x\n", DeviceDescriptor->bDescriptorType);
25     DPRINT("bcdUSB %x\n", DeviceDescriptor->bcdUSB);
26     DPRINT("bDeviceClass %x\n", DeviceDescriptor->bDeviceClass);
27     DPRINT("bDeviceSubClass %x\n", DeviceDescriptor->bDeviceSubClass);
28     DPRINT("bDeviceProtocol %x\n", DeviceDescriptor->bDeviceProtocol);
29     DPRINT("bMaxPacketSize0 %x\n", DeviceDescriptor->bMaxPacketSize0);
30     DPRINT("idVendor %x\n", DeviceDescriptor->idVendor);
31     DPRINT("idProduct %x\n", DeviceDescriptor->idProduct);
32     DPRINT("bcdDevice %x\n", DeviceDescriptor->bcdDevice);
33     DPRINT("iManufacturer %x\n", DeviceDescriptor->iManufacturer);
34     DPRINT("iProduct %x\n", DeviceDescriptor->iProduct);
35     DPRINT("iSerialNumber %x\n", DeviceDescriptor->iSerialNumber);
36     DPRINT("bNumConfigurations %x\n", DeviceDescriptor->bNumConfigurations);
37 }
38 #endif
39 
40 NTSTATUS
41 USBSTOR_FdoHandleDeviceRelations(
42     IN PFDO_DEVICE_EXTENSION DeviceExtension,
43     IN OUT PIRP Irp)
44 {
45     INT32 DeviceCount = 0;
46     LONG Index;
47     PDEVICE_RELATIONS DeviceRelations;
48     PIO_STACK_LOCATION IoStack;
49 
50     IoStack = IoGetCurrentIrpStackLocation(Irp);
51 
52     // FDO always only handles bus relations
53     if (IoStack->Parameters.QueryDeviceRelations.Type == BusRelations)
54     {
55         // go through array and count device objects
56         for (Index = 0; Index < max(DeviceExtension->MaxLUN, 1); Index++)
57         {
58             if (DeviceExtension->ChildPDO[Index])
59             {
60                 DeviceCount++;
61             }
62         }
63 
64         DeviceRelations = ExAllocatePoolWithTag(PagedPool, sizeof(DEVICE_RELATIONS) + (DeviceCount - 1) * sizeof(PDEVICE_OBJECT), USB_STOR_TAG);
65         if (!DeviceRelations)
66         {
67             Irp->IoStatus.Information = 0;
68             Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
69             IoCompleteRequest(Irp, IO_NO_INCREMENT);
70             return STATUS_INSUFFICIENT_RESOURCES;
71         }
72 
73         DeviceRelations->Count = 0;
74 
75         // add device objects
76         for (Index = 0; Index < max(DeviceExtension->MaxLUN, 1); Index++)
77         {
78             if (DeviceExtension->ChildPDO[Index])
79             {
80                 // store child pdo
81                 DeviceRelations->Objects[DeviceRelations->Count] = DeviceExtension->ChildPDO[Index];
82 
83                 // add reference
84                 ObReferenceObject(DeviceExtension->ChildPDO[Index]);
85 
86                 DeviceRelations->Count++;
87             }
88         }
89 
90         Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
91         Irp->IoStatus.Status = STATUS_SUCCESS;
92     }
93 
94     IoCopyCurrentIrpStackLocationToNext(Irp);
95 
96     return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
97 }
98 
99 NTSTATUS
100 USBSTOR_FdoHandleRemoveDevice(
101     IN PDEVICE_OBJECT DeviceObject,
102     IN PFDO_DEVICE_EXTENSION DeviceExtension,
103     IN OUT PIRP Irp)
104 {
105     NTSTATUS Status;
106     ULONG Index;
107 
108     DPRINT("Handling FDO removal %p\n", DeviceObject);
109 
110     // FIXME: wait for devices finished processing
111     for (Index = 0; Index < USB_MAXCHILDREN; Index++)
112     {
113         if (DeviceExtension->ChildPDO[Index] != NULL)
114         {
115             DPRINT("Deleting PDO %p RefCount %x AttachedDevice %p \n", DeviceExtension->ChildPDO[Index], DeviceExtension->ChildPDO[Index]->ReferenceCount, DeviceExtension->ChildPDO[Index]->AttachedDevice);
116             IoDeleteDevice(DeviceExtension->ChildPDO[Index]);
117         }
118     }
119 
120     // Freeing everything in DeviceExtension
121     ASSERT(
122         DeviceExtension->DeviceDescriptor &&
123         DeviceExtension->ConfigurationDescriptor &&
124         DeviceExtension->InterfaceInformation &&
125         DeviceExtension->ResetDeviceWorkItem
126     );
127 
128     ExFreePoolWithTag(DeviceExtension->DeviceDescriptor, USB_STOR_TAG);
129     ExFreePoolWithTag(DeviceExtension->ConfigurationDescriptor, USB_STOR_TAG);
130     ExFreePoolWithTag(DeviceExtension->InterfaceInformation, USB_STOR_TAG);
131     IoFreeWorkItem(DeviceExtension->ResetDeviceWorkItem);
132 
133     if (DeviceExtension->SerialNumber)
134     {
135         ExFreePoolWithTag(DeviceExtension->SerialNumber, USB_STOR_TAG);
136     }
137 
138     // Send the IRP down the stack
139     IoSkipCurrentIrpStackLocation(Irp);
140     Irp->IoStatus.Status = STATUS_SUCCESS;
141     Status = IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
142 
143     // Detach from the device stack
144     IoDetachDevice(DeviceExtension->LowerDeviceObject);
145 
146     IoDeleteDevice(DeviceObject);
147 
148     return Status;
149 }
150 
151 NTSTATUS
152 USBSTOR_FdoHandleStartDevice(
153     IN PDEVICE_OBJECT DeviceObject,
154     IN PFDO_DEVICE_EXTENSION DeviceExtension,
155     IN OUT PIRP Irp)
156 {
157     PUSB_INTERFACE_DESCRIPTOR InterfaceDesc;
158     NTSTATUS Status;
159     UCHAR Index = 0;
160     PIO_WORKITEM WorkItem;
161 
162     // forward irp to lower device
163     Status = USBSTOR_SyncForwardIrp(DeviceExtension->LowerDeviceObject, Irp);
164     if (!NT_SUCCESS(Status))
165     {
166         DPRINT1("USBSTOR_FdoHandleStartDevice Lower device failed to start %x\n", Status);
167         return Status;
168     }
169 
170     if (!DeviceExtension->ResetDeviceWorkItem)
171     {
172         WorkItem = IoAllocateWorkItem(DeviceObject);
173         DeviceExtension->ResetDeviceWorkItem = WorkItem;
174 
175         if (!WorkItem)
176         {
177             return STATUS_INSUFFICIENT_RESOURCES;
178         }
179     }
180 
181     // initialize irp queue
182     USBSTOR_QueueInitialize(DeviceExtension);
183 
184     // first get device & configuration & string descriptor
185     Status = USBSTOR_GetDescriptors(DeviceObject);
186     if (!NT_SUCCESS(Status))
187     {
188         DPRINT1("USBSTOR_FdoHandleStartDevice failed to get device descriptor with %x\n", Status);
189         return Status;
190     }
191 
192 #if DBG
193     USBSTOR_DumpDeviceDescriptor(DeviceExtension->DeviceDescriptor);
194 #endif
195 
196     // Check that this device uses bulk transfers and is SCSI
197 
198     InterfaceDesc = (PUSB_INTERFACE_DESCRIPTOR)((ULONG_PTR)DeviceExtension->ConfigurationDescriptor + sizeof(USB_CONFIGURATION_DESCRIPTOR));
199     ASSERT(InterfaceDesc->bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE);
200     ASSERT(InterfaceDesc->bLength == sizeof(USB_INTERFACE_DESCRIPTOR));
201 
202     DPRINT("bInterfaceSubClass %x\n", InterfaceDesc->bInterfaceSubClass);
203     if (InterfaceDesc->bInterfaceProtocol != USB_PROTOCOL_BULK)
204     {
205         DPRINT1("USB Device is not a bulk only device and is not currently supported\n");
206         return STATUS_NOT_SUPPORTED;
207     }
208 
209     if (InterfaceDesc->bInterfaceSubClass == USB_SUBCLASS_UFI)
210     {
211         DPRINT1("USB Floppy devices are not supported\n");
212         return STATUS_NOT_SUPPORTED;
213     }
214 
215     // now select an interface
216     Status = USBSTOR_SelectConfigurationAndInterface(DeviceObject, DeviceExtension);
217     if (!NT_SUCCESS(Status))
218     {
219         // failed to get device descriptor
220         DPRINT1("USBSTOR_FdoHandleStartDevice failed to select configuration / interface with %x\n", Status);
221         return Status;
222     }
223 
224     // check if we got a bulk in + bulk out endpoint
225     Status = USBSTOR_GetPipeHandles(DeviceExtension);
226     if (!NT_SUCCESS(Status))
227     {
228         DPRINT1("USBSTOR_FdoHandleStartDevice no pipe handles %x\n", Status);
229         return Status;
230     }
231 
232     Status = USBSTOR_GetMaxLUN(DeviceExtension->LowerDeviceObject, DeviceExtension);
233     if (!NT_SUCCESS(Status))
234     {
235         DPRINT1("USBSTOR_FdoHandleStartDevice failed to get max lun %x\n", Status);
236         return Status;
237     }
238 
239     // now create for each LUN a device object, 1 minimum
240     do
241     {
242         Status = USBSTOR_CreatePDO(DeviceObject, Index);
243 
244         if (!NT_SUCCESS(Status))
245         {
246             DPRINT1("USBSTOR_FdoHandleStartDevice USBSTOR_CreatePDO failed for Index %lu with Status %x\n", Index, Status);
247             return Status;
248         }
249 
250         Index++;
251         DeviceExtension->InstanceCount++;
252 
253     } while(Index < DeviceExtension->MaxLUN);
254 
255 #if 0
256     //
257     // finally get usb device interface
258     //
259     Status = USBSTOR_GetBusInterface(DeviceExtension->LowerDeviceObject, &DeviceExtension->BusInterface);
260     if (!NT_SUCCESS(Status))
261     {
262         //
263         // failed to device interface
264         //
265         DPRINT1("USBSTOR_FdoHandleStartDevice failed to get device interface %x\n", Status);
266         return Status;
267     }
268 #endif
269 
270     //IoStartTimer(DeviceObject);
271 
272     DPRINT("USBSTOR_FdoHandleStartDevice FDO is initialized\n");
273     return STATUS_SUCCESS;
274 }
275 
276 NTSTATUS
277 USBSTOR_FdoHandlePnp(
278     IN PDEVICE_OBJECT DeviceObject,
279     IN OUT PIRP Irp)
280 {
281     PIO_STACK_LOCATION IoStack;
282     PFDO_DEVICE_EXTENSION DeviceExtension;
283     NTSTATUS Status;
284 
285     IoStack = IoGetCurrentIrpStackLocation(Irp);
286     DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
287     ASSERT(DeviceExtension->Common.IsFDO);
288 
289     switch(IoStack->MinorFunction)
290     {
291         case IRP_MN_SURPRISE_REMOVAL:
292         {
293             DPRINT("IRP_MN_SURPRISE_REMOVAL %p\n", DeviceObject);
294             Irp->IoStatus.Status = STATUS_SUCCESS;
295 
296             // forward irp to next device object
297             IoSkipCurrentIrpStackLocation(Irp);
298             return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
299         }
300         case IRP_MN_QUERY_DEVICE_RELATIONS:
301         {
302             DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS %p Type: %u\n", DeviceObject, IoStack->Parameters.QueryDeviceRelations.Type);
303             return USBSTOR_FdoHandleDeviceRelations(DeviceExtension, Irp);
304         }
305         case IRP_MN_STOP_DEVICE:
306         {
307             DPRINT1("USBSTOR_FdoHandlePnp: IRP_MN_STOP_DEVICE unimplemented\n");
308             IoStopTimer(DeviceObject);
309             Irp->IoStatus.Status = STATUS_SUCCESS;
310 
311             // forward irp to next device object
312             IoSkipCurrentIrpStackLocation(Irp);
313             return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
314         }
315         case IRP_MN_REMOVE_DEVICE:
316         {
317             DPRINT("IRP_MN_REMOVE_DEVICE\n");
318 
319             return USBSTOR_FdoHandleRemoveDevice(DeviceObject, DeviceExtension, Irp);
320         }
321         case IRP_MN_QUERY_CAPABILITIES:
322         {
323             // FIXME: set custom capabilities
324             IoSkipCurrentIrpStackLocation(Irp);
325             return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
326         }
327         case IRP_MN_QUERY_STOP_DEVICE:
328         case IRP_MN_QUERY_REMOVE_DEVICE:
329         {
330 #if 0
331             //
332             // we can if nothing is pending
333             //
334             if (DeviceExtension->IrpPendingCount != 0 ||
335                 DeviceExtension->ActiveSrb != NULL)
336 #else
337             if (TRUE)
338 #endif
339             {
340                 /* We have pending requests */
341                 DPRINT1("Failing removal/stop request due to pending requests present\n");
342                 Status = STATUS_UNSUCCESSFUL;
343             }
344             else
345             {
346                 /* We're all clear */
347                 Irp->IoStatus.Status = STATUS_SUCCESS;
348 
349                 IoSkipCurrentIrpStackLocation(Irp);
350                 return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
351             }
352             break;
353         }
354         case IRP_MN_START_DEVICE:
355         {
356             Status = USBSTOR_FdoHandleStartDevice(DeviceObject, DeviceExtension, Irp);
357             break;
358         }
359         default:
360         {
361             // forward irp to next device object
362             IoSkipCurrentIrpStackLocation(Irp);
363             return IoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
364         }
365     }
366 
367     if (Status != STATUS_PENDING)
368     {
369         Irp->IoStatus.Status = Status;
370         IoCompleteRequest(Irp, IO_NO_INCREMENT);
371     }
372 
373     return Status;
374 }
375