reactos/drivers/usb/usbstor/misc.c

   1 /*
   2  * PROJECT:     ReactOS Universal Serial Bus Bulk Storage Driver
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        drivers/usb/usbstor/misc.c
   5  * PURPOSE:     USB block storage device driver.
   6  * PROGRAMMERS:
   7  *              James Tabor
   8  *              Michael Martin (michael.martin@reactos.org)
   9  *              Johannes Anderwald (johannes.anderwald@reactos.org)
  10  */
  11
  12 #include "usbstor.h"
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 //
  18 // driver verifier
  19 //
  20 IO_COMPLETION_ROUTINE SyncForwardIrpCompletionRoutine;
  21
  22 NTSTATUS
  23 NTAPI
  24 USBSTOR_SyncForwardIrpCompletionRoutine(
  25     PDEVICE_OBJECT DeviceObject,
  26     PIRP Irp,
  27     PVOID Context)
  28 {
  29     if (Irp->PendingReturned)
  30     {
  31         KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, FALSE);
  32     }
  33     return STATUS_MORE_PROCESSING_REQUIRED;
  34 }
  35
  36 NTSTATUS
  37 NTAPI
  38 USBSTOR_SyncForwardIrp(PDEVICE_OBJECT DeviceObject, PIRP Irp)
  39 {
  40     KEVENT Event;
  41     NTSTATUS Status;
  42
  43     //
  44     // initialize event
  45     //
  46     KeInitializeEvent(&Event, NotificationEvent, FALSE);
  47
  48     //
  49     // copy irp stack location
  50     //
  51     IoCopyCurrentIrpStackLocationToNext(Irp);
  52
  53     //
  54     // set completion routine
  55     //
  56     IoSetCompletionRoutine(Irp, USBSTOR_SyncForwardIrpCompletionRoutine, &Event, TRUE, TRUE, TRUE);
  57
  58
  59     //
  60     // call driver
  61     //
  62     Status = IoCallDriver(DeviceObject, Irp);
  63
  64     //
  65     // check if pending
  66     //
  67     if (Status == STATUS_PENDING)
  68     {
  69         //
  70         // wait for the request to finish
  71         //
  72         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
  73
  74         //
  75         // copy status code
  76         //
  77         Status = Irp->IoStatus.Status;
  78     }
  79
  80     //
  81     // done
  82     //
  83     return Status;
  84 }
  85
  86 NTSTATUS
  87 NTAPI
  88 USBSTOR_GetBusInterface(
  89     IN PDEVICE_OBJECT DeviceObject,
  90     OUT PUSB_BUS_INTERFACE_USBDI_V2 BusInterface)
  91 {
  92     KEVENT Event;
  93     NTSTATUS Status;
  94     PIRP Irp;
  95     IO_STATUS_BLOCK IoStatus;
  96     PIO_STACK_LOCATION Stack;
  97
  98     //
  99     // sanity checks
 100     //
 101     ASSERT(DeviceObject);
 102     ASSERT(BusInterface);
 103
 104
 105     //
 106     // initialize event
 107     //
 108     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 109
 110
 111     //
 112     // create irp
 113     //
 114     Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
 115                                        DeviceObject,
 116                                        NULL,
 117                                        0,
 118                                        NULL,
 119                                        &Event,
 120                                        &IoStatus);
 121
 122     //
 123     // was irp built
 124     //
 125     if (Irp == NULL)
 126     {
 127         //
 128         // no memory
 129         //
 130         return STATUS_INSUFFICIENT_RESOURCES;
 131     }
 132
 133     //
 134     // initialize request
 135     //
 136     Stack=IoGetNextIrpStackLocation(Irp);
 137     Stack->MajorFunction = IRP_MJ_PNP;
 138     Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
 139     Stack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
 140     Stack->Parameters.QueryInterface.InterfaceType = (LPGUID)&USB_BUS_INTERFACE_USBDI_GUID;
 141     Stack->Parameters.QueryInterface.Version = 2;
 142     Stack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
 143     Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
 144     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 145
 146     //
 147     // call driver
 148     //
 149     Status= IoCallDriver(DeviceObject, Irp);
 150
 151     //
 152     // did operation complete
 153     //
 154     if (Status == STATUS_PENDING)
 155     {
 156         //
 157         // wait for completion
 158         //
 159         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 160
 161         //
 162         // collect status
 163         //
 164         Status=IoStatus.Status;
 165     }
 166
 167     return Status;
 168 }
 169
 170 NTSTATUS
 171 USBSTOR_SyncUrbRequest(
 172     IN PDEVICE_OBJECT DeviceObject,
 173     OUT PURB UrbRequest)
 174 {
 175     PIRP Irp;
 176     PIO_STACK_LOCATION IoStack;
 177     KEVENT Event;
 178     NTSTATUS Status;
 179
 180     //
 181     // allocate irp
 182     //
 183     Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
 184     if (!Irp)
 185     {
 186         //
 187         // no memory
 188         //
 189         return STATUS_INSUFFICIENT_RESOURCES;
 190     }
 191
 192     //
 193     // initialize event
 194     //
 195     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 196
 197
 198     //
 199     // get next stack location
 200     //
 201     IoStack = IoGetNextIrpStackLocation(Irp);
 202
 203     //
 204     // initialize stack location
 205     //
 206     IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
 207     IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
 208     IoStack->Parameters.Others.Argument1 = (PVOID)UrbRequest;
 209     IoStack->Parameters.DeviceIoControl.InputBufferLength = UrbRequest->UrbHeader.Length;
 210     Irp->IoStatus.Status = STATUS_SUCCESS;
 211
 212     //
 213     // setup completion routine
 214     //
 215     IoSetCompletionRoutine(Irp, USBSTOR_SyncForwardIrpCompletionRoutine, &Event, TRUE, TRUE, TRUE);
 216
 217     //
 218     // call driver
 219     //
 220     Status = IoCallDriver(DeviceObject, Irp);
 221
 222     //
 223     // check if request is pending
 224     //
 225     if (Status == STATUS_PENDING)
 226     {
 227         //
 228         // wait for completion
 229         //
 230         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 231
 232         //
 233         // update status
 234         //
 235         Status = Irp->IoStatus.Status;
 236     }
 237
 238     //
 239     // free irp
 240     //
 241     IoFreeIrp(Irp);
 242
 243     //
 244     // done
 245     //
 246     return Status;
 247 }
 248
 249 PVOID
 250 AllocateItem(
 251     IN POOL_TYPE PoolType,
 252     IN ULONG ItemSize)
 253 {
 254     //
 255     // allocate item
 256     //
 257     PVOID Item = ExAllocatePoolWithTag(PoolType, ItemSize, USB_STOR_TAG);
 258
 259     if (Item)
 260     {
 261         //
 262         // zero item
 263         //
 264         RtlZeroMemory(Item, ItemSize);
 265     }
 266
 267     //
 268     // return element
 269     //
 270     return Item;
 271 }
 272
 273 VOID
 274 FreeItem(
 275     IN PVOID Item)
 276 {
 277     //
 278     // free item
 279     //
 280     ExFreePoolWithTag(Item, USB_STOR_TAG);
 281 }
 282
 283 NTSTATUS
 284 USBSTOR_ClassRequest(
 285     IN PDEVICE_OBJECT DeviceObject,
 286     IN PFDO_DEVICE_EXTENSION DeviceExtension,
 287     IN UCHAR RequestType,
 288     IN USHORT Index,
 289     IN ULONG TransferFlags,
 290     IN ULONG TransferBufferLength,
 291     IN PVOID TransferBuffer)
 292
 293 {
 294     PURB Urb;
 295     NTSTATUS Status;
 296
 297     //
 298     // first allocate urb
 299     //
 300     Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
 301     if (!Urb)
 302     {
 303         //
 304         // no memory
 305         //
 306         return STATUS_INSUFFICIENT_RESOURCES;
 307     }
 308
 309     //
 310     // initialize vendor request
 311     //
 312     Urb->UrbControlVendorClassRequest.Hdr.Length = sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST);
 313     Urb->UrbControlVendorClassRequest.Hdr.Function = URB_FUNCTION_CLASS_INTERFACE;
 314     Urb->UrbControlVendorClassRequest.TransferFlags = TransferFlags;
 315     Urb->UrbControlVendorClassRequest.TransferBufferLength = TransferBufferLength;
 316     Urb->UrbControlVendorClassRequest.TransferBuffer = TransferBuffer;
 317     Urb->UrbControlVendorClassRequest.Request = RequestType;
 318     Urb->UrbControlVendorClassRequest.Index = Index;
 319
 320     //
 321     // submit request
 322     //
 323     Status = USBSTOR_SyncUrbRequest(DeviceObject, Urb);
 324
 325     //
 326     // free urb
 327     //
 328     FreeItem(Urb);
 329
 330     //
 331     // done
 332     //
 333     return Status;
 334 }
 335
 336
 337 NTSTATUS
 338 USBSTOR_GetMaxLUN(
 339     IN PDEVICE_OBJECT DeviceObject,
 340     IN PFDO_DEVICE_EXTENSION DeviceExtension)
 341 {
 342     PUCHAR Buffer;
 343     NTSTATUS Status;
 344
 345     //
 346     // allocate 1-byte buffer
 347     //
 348     Buffer = (PUCHAR)AllocateItem(NonPagedPool, sizeof(UCHAR));
 349     if (!Buffer)
 350     {
 351         //
 352         // no memory
 353         //
 354         FreeItem(Buffer);
 355         return STATUS_INSUFFICIENT_RESOURCES;
 356     }
 357
 358     //
 359     // execute request
 360     //
 361     Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_GET_MAX_LUN, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_IN, sizeof(UCHAR), Buffer);
 362
 363     DPRINT("MaxLUN: %x\n", *Buffer);
 364
 365     if (*Buffer > 0xF)
 366     {
 367         //
 368         // invalid response documented in usb mass storage specification
 369         //
 370         Status = STATUS_DEVICE_DATA_ERROR;
 371     }
 372     else
 373     {
 374         //
 375         // store maxlun
 376         //
 377         DeviceExtension->MaxLUN = *Buffer;
 378     }
 379
 380     //
 381     // free buffer
 382     //
 383     FreeItem(Buffer);
 384
 385     //
 386     // done
 387     //
 388     return Status;
 389
 390 }
 391
 392 NTSTATUS
 393 USBSTOR_ResetDevice(
 394     IN PDEVICE_OBJECT DeviceObject,
 395     IN PFDO_DEVICE_EXTENSION DeviceExtension)
 396 {
 397     NTSTATUS Status;
 398
 399     //
 400     // execute request
 401     //
 402     Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_RESET_DEVICE, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_OUT, 0, NULL);
 403
 404     //
 405     // done
 406     //
 407     return Status;
 408
 409 }
 410
 411 BOOLEAN
 412 USBSTOR_IsFloppy(
 413     IN PUCHAR Buffer,
 414     IN ULONG BufferLength,
 415     OUT PUCHAR MediumTypeCode)
 416 {
 417     PUFI_CAPACITY_FORMAT_HEADER FormatHeader;
 418     PUFI_CAPACITY_DESCRIPTOR Descriptor;
 419     ULONG Length, Index, BlockCount, BlockLength;
 420
 421     //
 422     // get format header
 423     //
 424     FormatHeader = (PUFI_CAPACITY_FORMAT_HEADER)Buffer;
 425
 426     //
 427     // sanity checks
 428     //
 429     ASSERT(FormatHeader->Reserved1 == 0x00);
 430     ASSERT(FormatHeader->Reserved2 == 0x00);
 431     ASSERT(FormatHeader->Reserved3 == 0x00);
 432
 433     //
 434     // is there capacity data
 435     //
 436     if (!FormatHeader->CapacityLength)
 437     {
 438         //
 439         // no data provided
 440         //
 441         DPRINT1("[USBSTOR] No capacity length\n");
 442         return FALSE;
 443     }
 444
 445     //
 446     // the format header are always 8 bytes in length
 447     //
 448     ASSERT((FormatHeader->CapacityLength & 0x7) == 0);
 449     DPRINT1("CapacityLength %x\n", FormatHeader->CapacityLength);
 450
 451     //
 452     // grab length and locate first descriptor
 453     //
 454     Length = FormatHeader->CapacityLength;
 455     Descriptor = (PUFI_CAPACITY_DESCRIPTOR)(FormatHeader + 1);
 456     for(Index = 0; Index < Length / sizeof(UFI_CAPACITY_DESCRIPTOR); Index++)
 457     {
 458         //
 459         // blocks are little endian format
 460         //
 461         BlockCount = NTOHL(Descriptor->BlockCount);
 462
 463         //
 464         // get block length
 465         //
 466         BlockLength = NTOHL((Descriptor->BlockLengthByte0 << 24 | Descriptor->BlockLengthByte1 << 16 | Descriptor->BlockLengthByte2 << 8));
 467
 468         DPRINT1("BlockCount %x BlockLength %x Code %x\n", BlockCount, BlockLength, Descriptor->Code);
 469
 470         if (BlockLength == 512 && BlockCount == 1440)
 471         {
 472             //
 473             // 720 KB DD
 474             //
 475             *MediumTypeCode = 0x1E;
 476             return TRUE;
 477         }
 478         else if (BlockLength == 1024 && BlockCount == 1232)
 479         {
 480             //
 481             // 1,25 MB
 482             //
 483             *MediumTypeCode = 0x93;
 484             return TRUE;
 485         }
 486         else if (BlockLength == 512 && BlockCount == 2880)
 487         {
 488             //
 489             // 1,44MB KB DD
 490             //
 491             *MediumTypeCode = 0x94;
 492             return TRUE;
 493         }
 494
 495         //
 496         // move to next descriptor
 497         //
 498         Descriptor = (Descriptor + 1);
 499     }
 500
 501     //
 502     // no floppy detected
 503     //
 504     return FALSE;
 505 }