reactos/drivers/wdm/audio/backpln/portcls/irpstream.cpp

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/wdm/audio/backpln/portcls/irpstream.cpp
   5  * PURPOSE:         IRP Stream handling
   6  * PROGRAMMER:      Johannes Anderwald
   7  */
   8
   9 #include "private.hpp"
  10
  11
  12 class CIrpQueue : public IIrpQueue
  13 {
  14 public:
  15     STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
  16
  17     STDMETHODIMP_(ULONG) AddRef()
  18     {
  19         InterlockedIncrement(&m_Ref);
  20         return m_Ref;
  21     }
  22     STDMETHODIMP_(ULONG) Release()
  23     {
  24         InterlockedDecrement(&m_Ref);
  25
  26         if (!m_Ref)
  27         {
  28             delete this;
  29             return 0;
  30         }
  31         return m_Ref;
  32     }
  33     IMP_IIrpQueue;
  34     CIrpQueue(IUnknown *OuterUnknown){}
  35     virtual ~CIrpQueue(){}
  36
  37 protected:
  38     volatile ULONG m_CurrentOffset;
  39     LONG m_NumMappings;
  40     ULONG m_NumDataAvailable;
  41     PKSPIN_CONNECT m_ConnectDetails;
  42     KSPIN_LOCK m_IrpListLock;
  43     LIST_ENTRY m_IrpList;
  44     LIST_ENTRY m_FreeIrpList;
  45     PIRP m_Irp;
  46
  47     ULONG m_OutOfMapping;
  48     ULONG m_MaxFrameSize;
  49     ULONG m_Alignment;
  50
  51     LONG m_Ref;
  52
  53 };
  54
  55 #define OFFSET_HEADERINDEX  (0)
  56 #define OFFSET_STREAMHEADER (2)
  57 #define OFFSET_HEADERCOUNT  (3)
  58
  59
  60 #define STREAMHEADER_INDEX(Irp)   (PtrToUlong(Irp->Tail.Overlay.DriverContext[OFFSET_HEADERINDEX]))
  61 #define STREAMHEADER_COUNT(Irp)   (PtrToUlong(Irp->Tail.Overlay.DriverContext[OFFSET_HEADERCOUNT]))
  62 #define STREAMHEADER_CURRENT(Irp) (Irp->Tail.Overlay.DriverContext[OFFSET_STREAMHEADER])
  63
  64
  65 NTSTATUS
  66 NTAPI
  67 CIrpQueue::QueryInterface(
  68     IN  REFIID refiid,
  69     OUT PVOID* Output)
  70 {
  71     if (IsEqualGUIDAligned(refiid, IID_IUnknown))
  72     {
  73         *Output = PVOID(PUNKNOWN(this));
  74         PUNKNOWN(*Output)->AddRef();
  75         return STATUS_SUCCESS;
  76     }
  77
  78     return STATUS_UNSUCCESSFUL;
  79 }
  80
  81 NTSTATUS
  82 NTAPI
  83 CIrpQueue::Init(
  84     IN KSPIN_CONNECT *ConnectDetails,
  85     IN ULONG FrameSize,
  86     IN ULONG Alignment)
  87 {
  88     m_ConnectDetails = ConnectDetails;
  89     m_MaxFrameSize = FrameSize;
  90     m_Alignment = Alignment;
  91
  92     InitializeListHead(&m_IrpList);
  93     InitializeListHead(&m_FreeIrpList);
  94     KeInitializeSpinLock(&m_IrpListLock);
  95
  96     return STATUS_SUCCESS;
  97 }
  98
  99 NTSTATUS
 100 NTAPI
 101 CIrpQueue::AddMapping(
 102     IN PIRP Irp,
 103     OUT PULONG Data)
 104 {
 105     PKSSTREAM_HEADER Header;
 106     NTSTATUS Status = STATUS_SUCCESS;
 107     PIO_STACK_LOCATION IoStack;
 108     ULONG NumHeaders, NumData, Index;
 109     PMDL Mdl;
 110
 111     PC_ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 112
 113     // get current irp stack location
 114     IoStack = IoGetCurrentIrpStackLocation(Irp);
 115
 116     if (!Irp->MdlAddress)
 117     {
 118         // ioctl from KsStudio
 119         // Wdmaud already probes buffers, therefore no need to probe it again
 120         // probe the stream irp
 121         if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM)
 122             Status = KsProbeStreamIrp(Irp, KSSTREAM_WRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_SYSTEMADDRESS, 0);
 123         else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_READ_STREAM)
 124             Status = KsProbeStreamIrp(Irp, KSSTREAM_READ  | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_SYSTEMADDRESS, 0);
 125         else
 126             PC_ASSERT(0);
 127
 128         // check for success
 129         if (!NT_SUCCESS(Status))
 130         {
 131             DPRINT("KsProbeStreamIrp failed with %x\n", Status);
 132             return Status;
 133         }
 134     }
 135
 136     // get first stream header
 137
 138    if (Irp->RequestorMode == UserMode)
 139        Header = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
 140    else
 141        Header = (PKSSTREAM_HEADER)Irp->UserBuffer;
 142
 143     // sanity check
 144     PC_ASSERT(Header);
 145
 146     // calculate num headers
 147     NumHeaders = IoStack->Parameters.DeviceIoControl.OutputBufferLength / Header->Size;
 148
 149     // assume headers of same length
 150     PC_ASSERT(IoStack->Parameters.DeviceIoControl.OutputBufferLength % Header->Size == 0);
 151
 152
 153     // get first audio buffer
 154     Mdl = Irp->MdlAddress;
 155     // sanity check
 156     PC_ASSERT(Mdl);
 157
 158     // store the current stream header
 159     Irp->Tail.Overlay.DriverContext[OFFSET_STREAMHEADER] = (PVOID)Header;
 160     // store header count
 161     Irp->Tail.Overlay.DriverContext[OFFSET_HEADERCOUNT] = UlongToPtr(NumHeaders);
 162
 163     // store current header index
 164     Irp->Tail.Overlay.DriverContext[OFFSET_HEADERINDEX] = UlongToPtr(0);
 165
 166     NumData = 0;
 167     // prepare all headers
 168     for(Index = 0; Index < NumHeaders; Index++)
 169     {
 170         // sanity checks
 171         PC_ASSERT(Header);
 172         PC_ASSERT(Mdl);
 173
 174         if (Irp->RequestorMode == UserMode)
 175         {
 176             Header->Data = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
 177         }
 178
 179         if (!Header->Data)
 180         {
 181             // insufficient resources
 182             ExFreePool(Irp->AssociatedIrp.SystemBuffer);
 183             Irp->AssociatedIrp.SystemBuffer = NULL;
 184             // complete and forget request
 185             Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
 186             Irp->IoStatus.Information = 0;
 187
 188             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 189             return STATUS_INSUFFICIENT_RESOURCES;
 190         }
 191
 192         // increment num mappings
 193         InterlockedIncrement(&m_NumMappings);
 194
 195         // increment available data
 196         InterlockedExchangeAdd((PLONG)&m_NumDataAvailable,
 197                                       (max(Header->DataUsed, Header->FrameExtent)));
 198
 199         NumData += max(Header->DataUsed, Header->FrameExtent);
 200
 201         // move to next header
 202         Header = (PKSSTREAM_HEADER)((ULONG_PTR)Header + Header->Size);
 203
 204         // move to next mdl
 205         Mdl = Mdl->Next;
 206     }
 207
 208     DPRINT("StreamHeaders %u NumData %u FrameSize %u NumDataAvailable %u\n", NumHeaders, NumData, m_MaxFrameSize, m_NumDataAvailable);
 209     *Data = NumData;
 210
 211     // mark irp as pending
 212     IoMarkIrpPending(Irp);
 213
 214     // add irp to cancelable queue
 215     KsAddIrpToCancelableQueue(&m_IrpList, &m_IrpListLock, Irp, KsListEntryTail, NULL);
 216
 217     // disable mapping failed status
 218     m_OutOfMapping = FALSE;
 219
 220     // done
 221     return Status;
 222 }
 223
 224 NTSTATUS
 225 NTAPI
 226 CIrpQueue::GetMapping(
 227     OUT PUCHAR * Buffer,
 228     OUT PULONG BufferSize)
 229 {
 230     PIRP Irp;
 231     ULONG Offset;
 232     //PIO_STACK_LOCATION IoStack;
 233     PKSSTREAM_HEADER StreamHeader;
 234
 235     // check if there is an irp in the partially processed
 236     if (m_Irp)
 237     {
 238         // use last irp
 239         if (m_Irp->Cancel == FALSE)
 240         {
 241             Irp = m_Irp;
 242             Offset = m_CurrentOffset;
 243         }
 244         else
 245         {
 246             // irp has been cancelled
 247             m_Irp->IoStatus.Status = STATUS_CANCELLED;
 248             IoCompleteRequest(m_Irp, IO_NO_INCREMENT);
 249             m_Irp = Irp = NULL;
 250         }
 251     }
 252     else
 253     {
 254         // get a fresh new irp from the queue
 255         m_Irp = Irp = KsRemoveIrpFromCancelableQueue(&m_IrpList, &m_IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
 256         m_CurrentOffset = Offset = 0;
 257     }
 258
 259     if (!Irp)
 260     {
 261         // no irp buffer available
 262         DPRINT("NoIrp\n");
 263         return STATUS_UNSUCCESSFUL;
 264     }
 265
 266     // get stream header
 267     StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
 268
 269     // sanity check
 270     PC_ASSERT(StreamHeader);
 271
 272     // store buffersize
 273     if (StreamHeader->DataUsed)
 274         *BufferSize = StreamHeader->DataUsed - Offset;
 275     else
 276         *BufferSize = StreamHeader->FrameExtent - Offset;
 277
 278     PC_ASSERT(*BufferSize);
 279
 280     // store buffer
 281     *Buffer = &((PUCHAR)StreamHeader->Data)[Offset];
 282
 283     // unset flag that no irps are available
 284     m_OutOfMapping = FALSE;
 285
 286     return STATUS_SUCCESS;
 287 }
 288
 289 VOID
 290 NTAPI
 291 CIrpQueue::UpdateMapping(
 292     IN ULONG BytesWritten)
 293 {
 294     PKSSTREAM_HEADER StreamHeader;
 295     ULONG Size, NumData, Index;
 296     //PMDL CurMdl, NextMdl;
 297
 298     if (!m_Irp)
 299     {
 300         // silence buffer was used
 301         return;
 302     }
 303
 304     // get stream header
 305     StreamHeader = (PKSSTREAM_HEADER)STREAMHEADER_CURRENT(m_Irp);
 306
 307     // sanity check
 308    // ASSERT(StreamHeader);
 309
 310     // add to current offset
 311     InterlockedExchangeAdd((volatile PLONG)&m_CurrentOffset, (LONG)BytesWritten);
 312
 313     // decrement available data counter
 314     m_NumDataAvailable -= BytesWritten;
 315
 316     if (StreamHeader->DataUsed)
 317         Size = StreamHeader->DataUsed;
 318     else
 319         Size = StreamHeader->FrameExtent;
 320
 321     PC_ASSERT(Size);
 322
 323     if (m_CurrentOffset >= Size)
 324     {
 325         if (STREAMHEADER_INDEX(m_Irp) + 1 < STREAMHEADER_COUNT(m_Irp))
 326         {
 327             // the irp has at least one more stream header
 328             m_Irp->Tail.Overlay.DriverContext[OFFSET_HEADERINDEX] = UlongToPtr(STREAMHEADER_INDEX(m_Irp) + 1);
 329
 330             // get next stream header
 331             StreamHeader = (PKSSTREAM_HEADER)((ULONG_PTR)StreamHeader + StreamHeader->Size);
 332
 333             // store next stream header
 334             STREAMHEADER_CURRENT(m_Irp) = (PVOID)StreamHeader;
 335
 336             // reset current offset
 337             m_CurrentOffset = 0;
 338
 339             // done
 340             return;
 341         }
 342
 343        // irp has been processed completly
 344
 345         NumData = 0;
 346         if (m_Irp->RequestorMode == KernelMode)
 347             StreamHeader = (PKSSTREAM_HEADER)m_Irp->UserBuffer;
 348         else
 349             StreamHeader = (PKSSTREAM_HEADER)m_Irp->AssociatedIrp.SystemBuffer;
 350
 351         // loop all stream headers
 352         for(Index = 0; Index < STREAMHEADER_COUNT(m_Irp); Index++)
 353         {
 354             PC_ASSERT(StreamHeader);
 355
 356             // add size of buffer
 357             // depends on if the buffer is input / output
 358             if (StreamHeader->DataUsed)
 359                 Size = StreamHeader->DataUsed;
 360             else
 361                 Size = StreamHeader->FrameExtent;
 362
 363             // increment size
 364             NumData += Size;
 365
 366             // get next stream header
 367             StreamHeader = (PKSSTREAM_HEADER)((ULONG_PTR)StreamHeader + StreamHeader->Size);
 368         }
 369
 370         if (m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING)
 371         {
 372             // looped streaming repeat the buffers untill
 373             // the caller decides to stop the streams
 374
 375             // reset stream header index
 376             m_Irp->Tail.Overlay.DriverContext[OFFSET_HEADERINDEX] = UlongToPtr(0);
 377             // re-insert irp
 378             KsAddIrpToCancelableQueue(&m_IrpList, &m_IrpListLock, m_Irp, KsListEntryTail, NULL);
 379             // clear current irp
 380             m_Irp = NULL;
 381             // reset offset
 382             m_CurrentOffset = 0;
 383             // increment available data
 384             InterlockedExchangeAdd((PLONG)&m_NumDataAvailable, NumData);
 385             // done
 386             return;
 387         }
 388 #if 0
 389         // now free allocated mdls
 390         CurMdl = m_Irp->MdlAddress;
 391         for(Index = 0; Index < STREAMHEADER_COUNT(m_Irp); Index++)
 392         {
 393             // sanity check
 394             ASSERT(CurMdl);
 395
 396             // get next mdl
 397             NextMdl = CurMdl->Next;
 398
 399             // check if mdl is locked
 400             if (CurMdl->MdlFlags & MDL_PAGES_LOCKED)
 401             {
 402                 // unlock pages
 403                 MmUnlockPages(CurMdl);
 404             }
 405
 406             // free mdl
 407             IoFreeMdl(CurMdl);
 408
 409             // proceed to next mdl
 410             CurMdl = NextMdl;
 411         }
 412
 413         // all mdls have been freed now
 414         m_Irp->MdlAddress = NULL;
 415
 416         // free allocated KSSTREAM_HEADER
 417         ExFreePool(m_Irp->AssociatedIrp.SystemBuffer);
 418
 419         // is this really needed?
 420         m_Irp->AssociatedIrp.SystemBuffer = NULL;
 421 #endif
 422
 423         // store operation status
 424         m_Irp->IoStatus.Status = STATUS_SUCCESS;
 425         m_Irp->IoStatus.Information = NumData;
 426
 427         // complete the request
 428         IoCompleteRequest(m_Irp, IO_SOUND_INCREMENT);
 429
 430         // remove irp as it is complete
 431         m_Irp = NULL;
 432
 433         // reset offset
 434         m_CurrentOffset = 0;
 435     }
 436 }
 437
 438 ULONG
 439 NTAPI
 440 CIrpQueue::NumData()
 441 {
 442     // returns the amount of audio stream data available
 443     return m_NumDataAvailable;
 444 }
 445
 446 BOOL
 447 NTAPI
 448 CIrpQueue::CancelBuffers()
 449 {
 450     // is there an active irp
 451     if (m_Irp)
 452     {
 453         // re-insert it to cancelable queue
 454         KsAddIrpToCancelableQueue(&m_IrpList, &m_IrpListLock, m_Irp, KsListEntryTail, NULL);
 455         //set it to zero
 456         m_Irp = NULL;
 457     }
 458
 459     // cancel all irps
 460     KsCancelIo(&m_IrpList, &m_IrpListLock);
 461     // reset number of mappings
 462     m_NumMappings = 0;
 463     // reset number of data available
 464     m_NumDataAvailable = 0;
 465
 466     // done
 467     return TRUE;
 468 }
 469
 470 NTSTATUS
 471 NTAPI
 472 CIrpQueue::GetMappingWithTag(
 473     IN PVOID Tag,
 474     OUT PPHYSICAL_ADDRESS  PhysicalAddress,
 475     OUT PVOID  *VirtualAddress,
 476     OUT PULONG  ByteCount,
 477     OUT PULONG  Flags)
 478 {
 479     PKSSTREAM_HEADER StreamHeader;
 480     PIRP Irp;
 481
 482     *Flags = 0;
 483     PC_ASSERT(Tag != NULL);
 484
 485     // get an irp from the queue
 486     Irp = KsRemoveIrpFromCancelableQueue(&m_IrpList, &m_IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
 487
 488     // check if there is an irp
 489     if (!Irp)
 490     {
 491         // no irp available
 492         m_OutOfMapping = TRUE;
 493         return STATUS_NOT_FOUND;
 494     }
 495
 496     //FIXME support more than one stream header
 497     PC_ASSERT(STREAMHEADER_COUNT(Irp) == 1);
 498
 499     // HACK get stream header
 500     StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
 501
 502     // store mapping in the free list
 503     ExInterlockedInsertTailList(&m_FreeIrpList, &Irp->Tail.Overlay.ListEntry, &m_IrpListLock);
 504
 505     // return mapping
 506     *PhysicalAddress = MmGetPhysicalAddress(StreamHeader->Data);
 507     *VirtualAddress = StreamHeader->Data;
 508     *ByteCount = StreamHeader->DataUsed;
 509
 510     // decrement mapping count
 511     InterlockedDecrement(&m_NumMappings);
 512     // decrement num data available
 513     m_NumDataAvailable -= StreamHeader->DataUsed;
 514
 515     // store tag in irp
 516     Irp->Tail.Overlay.DriverContext[3] = Tag;
 517
 518     // done
 519     return STATUS_SUCCESS;
 520 }
 521
 522 NTSTATUS
 523 NTAPI
 524 CIrpQueue::ReleaseMappingWithTag(
 525     IN PVOID Tag)
 526 {
 527     PIRP Irp;
 528     PLIST_ENTRY CurEntry;
 529     PKSSTREAM_HEADER StreamHeader;
 530
 531     DPRINT("CIrpQueue::ReleaseMappingWithTag Tag %p\n", Tag);
 532
 533     // remove irp from used list
 534     CurEntry = ExInterlockedRemoveHeadList(&m_FreeIrpList, &m_IrpListLock);
 535     // sanity check
 536     PC_ASSERT(CurEntry);
 537
 538     // get irp from list entry
 539     Irp = (PIRP)CONTAINING_RECORD(CurEntry, IRP, Tail.Overlay.ListEntry);
 540
 541     // HACK get stream header
 542     StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
 543
 544     // driver must release items in the same order
 545     PC_ASSERT(Irp->Tail.Overlay.DriverContext[3] == Tag);
 546
 547     // irp has been processed completly
 548     Irp->IoStatus.Status = STATUS_SUCCESS;
 549
 550     // frame extend contains the original request size, DataUsed contains the real buffer size
 551     // is different when kmixer performs channel conversion, upsampling etc
 552
 553     Irp->IoStatus.Information = StreamHeader->FrameExtent;
 554
 555     // complete the request
 556     IoCompleteRequest(Irp, IO_SOUND_INCREMENT);
 557
 558     return STATUS_SUCCESS;
 559 }
 560
 561 BOOLEAN
 562 NTAPI
 563 CIrpQueue::HasLastMappingFailed()
 564 {
 565     return m_OutOfMapping;
 566 }
 567
 568 ULONG
 569 NTAPI
 570 CIrpQueue::GetCurrentIrpOffset()
 571 {
 572
 573     return m_CurrentOffset;
 574 }
 575
 576 BOOLEAN
 577 NTAPI
 578 CIrpQueue::GetAcquiredTagRange(
 579     IN PVOID * FirstTag,
 580     IN PVOID * LastTag)
 581 {
 582     KIRQL OldLevel;
 583     BOOLEAN Ret = FALSE;
 584     PIRP Irp;
 585     PLIST_ENTRY CurEntry;
 586
 587     KeAcquireSpinLock(&m_IrpListLock, &OldLevel);
 588
 589     if (!IsListEmpty(&m_FreeIrpList))
 590     {
 591         // get first entry
 592         CurEntry = RemoveHeadList(&m_FreeIrpList);
 593         // get irp from list entry
 594         Irp = (PIRP)CONTAINING_RECORD(CurEntry, IRP, Tail.Overlay.ListEntry);
 595
 596         // get tag of first acquired buffer
 597         *FirstTag = Irp->Tail.Overlay.DriverContext[3];
 598
 599         // put back irp
 600         InsertHeadList(&m_FreeIrpList, &Irp->Tail.Overlay.ListEntry);
 601
 602         // get last entry
 603         CurEntry = RemoveTailList(&m_FreeIrpList);
 604         // get irp from list entry
 605         Irp = (PIRP)CONTAINING_RECORD(CurEntry, IRP, Tail.Overlay.ListEntry);
 606
 607         // get tag of first acquired buffer
 608         *LastTag = Irp->Tail.Overlay.DriverContext[3];
 609
 610         // put back irp
 611         InsertTailList(&m_FreeIrpList, &Irp->Tail.Overlay.ListEntry);
 612
 613         // indicate success
 614         Ret = TRUE;
 615     }
 616
 617     // release lock
 618     KeReleaseSpinLock(&m_IrpListLock, OldLevel);
 619     // done
 620     return Ret;
 621 }
 622
 623 NTSTATUS
 624 NTAPI
 625 NewIrpQueue(
 626     IN IIrpQueue **Queue)
 627 {
 628     CIrpQueue *This = new(NonPagedPool, TAG_PORTCLASS)CIrpQueue(NULL);
 629     if (!This)
 630         return STATUS_INSUFFICIENT_RESOURCES;
 631
 632     This->AddRef();
 633
 634     *Queue = (IIrpQueue*)This;
 635     return STATUS_SUCCESS;
 636 }
 637