![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to write.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / comm / serial|
Return to write.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / comm / serial |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1991, 1992, 1993 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: write.c ! 8: ! 9: Abstract: ! 10: ! 11: This module contains the code that is very specific to write ! 12: operations in the serial driver ! 13: ! 14: Author: ! 15: ! 16: Anthony V. Ercolano 26-Sep-1991 ! 17: ! 18: Environment: ! 19: ! 20: Kernel mode ! 21: ! 22: Revision History : ! 23: ! 24: --*/ ! 25: ! 26: #include <stddef.h> ! 27: #include "ntddk.h" ! 28: #include "ntddser.h" ! 29: #include "serial.h" ! 30: #include "serialp.h" ! 31: ! 32: ! 33: ! 34: BOOLEAN ! 35: SerialGiveWriteToIsr( ! 36: IN PVOID Context ! 37: ); ! 38: ! 39: VOID ! 40: SerialCancelCurrentWrite( ! 41: PDEVICE_OBJECT DeviceObject, ! 42: PIRP Irp ! 43: ); ! 44: ! 45: BOOLEAN ! 46: SerialGrabWriteFromIsr( ! 47: IN PVOID Context ! 48: ); ! 49: ! 50: BOOLEAN ! 51: SerialGrabXoffFromIsr( ! 52: IN PVOID Context ! 53: ); ! 54: ! 55: VOID ! 56: SerialCancelCurrentXoff( ! 57: PDEVICE_OBJECT DeviceObject, ! 58: PIRP Irp ! 59: ); ! 60: ! 61: BOOLEAN ! 62: SerialGiveXoffToIsr( ! 63: IN PVOID Context ! 64: ); ! 65: ! 66: ! 67: ! 68: NTSTATUS ! 69: SerialWrite( ! 70: IN PDEVICE_OBJECT DeviceObject, ! 71: IN PIRP Irp ! 72: ) ! 73: ! 74: /*++ ! 75: ! 76: Routine Description: ! 77: ! 78: This is the dispatch routine for write. It validates the parameters ! 79: for the write request and if all is ok then it places the request ! 80: on the work queue. ! 81: ! 82: Arguments: ! 83: ! 84: DeviceObject - Pointer to the device object for this device ! 85: ! 86: Irp - Pointer to the IRP for the current request ! 87: ! 88: Return Value: ! 89: ! 90: If the io is zero length then it will return STATUS_SUCCESS, ! 91: otherwise this routine will return STATUS_PENDING. ! 92: ! 93: --*/ ! 94: ! 95: { ! 96: ! 97: PSERIAL_DEVICE_EXTENSION Extension = DeviceObject->DeviceExtension; ! 98: ! 99: SerialDump( ! 100: SERIRPPATH, ! 101: ("SERIAL: Dispatch entry for: %x\n",Irp) ! 102: ); ! 103: if (SerialCompleteIfError( ! 104: DeviceObject, ! 105: Irp ! 106: ) != STATUS_SUCCESS) { ! 107: ! 108: return STATUS_CANCELLED; ! 109: ! 110: } ! 111: ! 112: Irp->IoStatus.Information = 0L; ! 113: ! 114: // ! 115: // Quick check for a zero length write. If it is zero length ! 116: // then we are already done! ! 117: // ! 118: ! 119: if (IoGetCurrentIrpStackLocation(Irp)->Parameters.Write.Length) { ! 120: ! 121: // ! 122: // Well it looks like we actually have to do some ! 123: // work. Put the write on the queue so that we can ! 124: // process it when our previous writes are done. ! 125: // ! 126: ! 127: return SerialStartOrQueue( ! 128: Extension, ! 129: Irp, ! 130: &Extension->WriteQueue, ! 131: &Extension->CurrentWriteIrp, ! 132: SerialStartWrite ! 133: ); ! 134: ! 135: } else { ! 136: ! 137: Irp->IoStatus.Status = STATUS_SUCCESS; ! 138: SerialDump( ! 139: SERIRPPATH, ! 140: ("SERIAL: Complete Irp: %x\n",Irp) ! 141: ); ! 142: IoCompleteRequest( ! 143: Irp, ! 144: 0 ! 145: ); ! 146: ! 147: return STATUS_SUCCESS; ! 148: ! 149: } ! 150: ! 151: } ! 152: ! 153: NTSTATUS ! 154: SerialStartWrite( ! 155: IN PSERIAL_DEVICE_EXTENSION Extension ! 156: ) ! 157: ! 158: /*++ ! 159: ! 160: Routine Description: ! 161: ! 162: This routine is used to start off any write. It initializes ! 163: the Iostatus fields of the irp. It will set up any timers ! 164: that are used to control the write. ! 165: ! 166: Arguments: ! 167: ! 168: Extension - Points to the serial device extension ! 169: ! 170: Return Value: ! 171: ! 172: This routine will return STATUS_PENDING for all writes ! 173: other than those that we find are cancelled. ! 174: ! 175: --*/ ! 176: ! 177: { ! 178: ! 179: PIRP NewIrp; ! 180: KIRQL OldIrql; ! 181: LARGE_INTEGER TotalTime; ! 182: BOOLEAN UseATimer; ! 183: SERIAL_TIMEOUTS Timeouts; ! 184: BOOLEAN SetFirstStatus = FALSE; ! 185: NTSTATUS FirstStatus; ! 186: ! 187: do { ! 188: ! 189: // ! 190: // If there is an xoff counter then complete it. ! 191: // ! 192: ! 193: IoAcquireCancelSpinLock(&OldIrql); ! 194: ! 195: // ! 196: // We see if there is a actually an Xoff counter irp. ! 197: // ! 198: // If there is, we put the write irp back on the head ! 199: // of the write list. We then kill the xoff counter. ! 200: // The xoff counter killing code will actually make the ! 201: // xoff counter back into the current write irp, and ! 202: // in the course of completing the xoff (which is now ! 203: // the current write) we will restart this irp. ! 204: // ! 205: ! 206: if (Extension->CurrentXoffIrp) { ! 207: ! 208: InsertHeadList( ! 209: &Extension->WriteQueue, ! 210: &Extension->CurrentWriteIrp->Tail.Overlay.ListEntry ! 211: ); ! 212: ! 213: if (!SetFirstStatus) { ! 214: ! 215: IoMarkIrpPending(Extension->CurrentWriteIrp); ! 216: SetFirstStatus = TRUE; ! 217: FirstStatus = STATUS_PENDING; ! 218: ! 219: } ! 220: ! 221: if (SERIAL_REFERENCE_COUNT(Extension->CurrentXoffIrp)) { ! 222: ! 223: // ! 224: // The reference count is non-zero. This implies that ! 225: // the xoff irp has not made it through the completion ! 226: // path yet. We will increment the reference count ! 227: // and attempt to complete it ourseleves. ! 228: // ! 229: ! 230: SERIAL_INC_REFERENCE(Extension->CurrentXoffIrp); ! 231: ! 232: Extension->CurrentWriteIrp = Extension->CurrentXoffIrp; ! 233: ! 234: // ! 235: // The following call will actually release the ! 236: // cancel spin lock. ! 237: // ! 238: ! 239: SerialTryToCompleteCurrent( ! 240: Extension, ! 241: SerialGrabXoffFromIsr, ! 242: OldIrql, ! 243: STATUS_SERIAL_MORE_WRITES, ! 244: &Extension->CurrentWriteIrp, ! 245: &Extension->WriteQueue, ! 246: NULL, ! 247: &Extension->XoffCountTimer, ! 248: SerialStartWrite, ! 249: SerialGetNextWrite ! 250: ); ! 251: ! 252: return FirstStatus; ! 253: ! 254: } else { ! 255: ! 256: // ! 257: // The irp is well on its way to being finished. ! 258: // We can let the regular completion code do the ! 259: // work. Just release the spin lock. ! 260: // ! 261: ! 262: IoReleaseCancelSpinLock(OldIrql); ! 263: ! 264: return FirstStatus; ! 265: ! 266: } ! 267: ! 268: } else { ! 269: ! 270: IoReleaseCancelSpinLock(OldIrql); ! 271: ! 272: } ! 273: ! 274: UseATimer = FALSE; ! 275: ! 276: // ! 277: // Calculate the timeout value needed for the ! 278: // request. Note that the values stored in the ! 279: // timeout record are in milliseconds. Note that ! 280: // if the timeout values are zero then we won't start ! 281: // the timer. ! 282: // ! 283: ! 284: KeAcquireSpinLock( ! 285: &Extension->ControlLock, ! 286: &OldIrql ! 287: ); ! 288: ! 289: Timeouts = Extension->Timeouts; ! 290: ! 291: KeReleaseSpinLock( ! 292: &Extension->ControlLock, ! 293: OldIrql ! 294: ); ! 295: ! 296: if (Timeouts.WriteTotalTimeoutConstant || ! 297: Timeouts.WriteTotalTimeoutMultiplier) { ! 298: ! 299: PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( ! 300: Extension->CurrentWriteIrp ! 301: ); ! 302: UseATimer = TRUE; ! 303: ! 304: // ! 305: // We have some timer values to calculate. ! 306: // ! 307: // Take care, we might have an xoff counter masquerading ! 308: // as a write. ! 309: // ! 310: ! 311: TotalTime = RtlEnlargedUnsignedMultiply( ! 312: (IrpSp->MajorFunction == IRP_MJ_WRITE)? ! 313: (IrpSp->Parameters.Write.Length): ! 314: (1), ! 315: Timeouts.WriteTotalTimeoutMultiplier ! 316: ); ! 317: ! 318: TotalTime = RtlLargeIntegerAdd( ! 319: TotalTime, ! 320: RtlConvertUlongToLargeInteger( ! 321: Timeouts.WriteTotalTimeoutConstant ! 322: ) ! 323: ); ! 324: ! 325: TotalTime = RtlExtendedIntegerMultiply( ! 326: TotalTime, ! 327: -10000 ! 328: ); ! 329: ! 330: } ! 331: ! 332: // ! 333: // The irp may be going to the isr shortly. Now ! 334: // is a good time to initialize its reference counts. ! 335: // ! 336: ! 337: SERIAL_INIT_REFERENCE(Extension->CurrentWriteIrp); ! 338: ! 339: // ! 340: // We need to see if this irp should be canceled. ! 341: // ! 342: ! 343: IoAcquireCancelSpinLock(&OldIrql); ! 344: if (Extension->CurrentWriteIrp->Cancel) { ! 345: ! 346: IoReleaseCancelSpinLock(OldIrql); ! 347: Extension->CurrentWriteIrp->IoStatus.Status = STATUS_CANCELLED; ! 348: ! 349: if (!SetFirstStatus) { ! 350: ! 351: FirstStatus = STATUS_CANCELLED; ! 352: SetFirstStatus = TRUE; ! 353: ! 354: } ! 355: ! 356: } else { ! 357: ! 358: if (!SetFirstStatus) { ! 359: ! 360: // ! 361: // If we haven't set our first status, then ! 362: // this is the only irp that could have possibly ! 363: // not been on the queue. (It could have been ! 364: // on the queue if this routine is being invoked ! 365: // from the completion routine.) Since this ! 366: // irp might never have been on the queue we ! 367: // should mark it as pending. ! 368: // ! 369: ! 370: IoMarkIrpPending(Extension->CurrentWriteIrp); ! 371: SetFirstStatus = TRUE; ! 372: FirstStatus = STATUS_PENDING; ! 373: ! 374: } ! 375: ! 376: // ! 377: // We give the irp to to the isr to write out. ! 378: // We set a cancel routine that knows how to ! 379: // grab the current write away from the isr. ! 380: // ! 381: // Since the cancel routine has an implicit reference ! 382: // to this irp up the reference count. ! 383: // ! 384: ! 385: IoSetCancelRoutine( ! 386: Extension->CurrentWriteIrp, ! 387: SerialCancelCurrentWrite ! 388: ); ! 389: ! 390: SERIAL_INC_REFERENCE(Extension->CurrentWriteIrp); ! 391: ! 392: if (UseATimer) { ! 393: ! 394: KeSetTimer( ! 395: &Extension->WriteRequestTotalTimer, ! 396: TotalTime, ! 397: &Extension->TotalWriteTimeoutDpc ! 398: ); ! 399: ! 400: // ! 401: // This timer now has a reference to the irp. ! 402: // ! 403: ! 404: SERIAL_INC_REFERENCE(Extension->CurrentWriteIrp); ! 405: } ! 406: ! 407: KeSynchronizeExecution( ! 408: Extension->Interrupt, ! 409: SerialGiveWriteToIsr, ! 410: Extension ! 411: ); ! 412: ! 413: IoReleaseCancelSpinLock(OldIrql); ! 414: break; ! 415: ! 416: } ! 417: ! 418: // ! 419: // Well the write was canceled before we could start it up. ! 420: // Try to get another. ! 421: // ! 422: ! 423: SerialGetNextWrite( ! 424: &Extension->CurrentWriteIrp, ! 425: &Extension->WriteQueue, ! 426: &NewIrp, ! 427: TRUE ! 428: ); ! 429: ! 430: } while (NewIrp); ! 431: ! 432: return FirstStatus; ! 433: ! 434: } ! 435: ! 436: VOID ! 437: SerialGetNextWrite( ! 438: IN PIRP *CurrentOpIrp, ! 439: IN PLIST_ENTRY QueueToProcess, ! 440: IN PIRP *NewIrp, ! 441: IN BOOLEAN CompleteCurrent ! 442: ) ! 443: ! 444: /*++ ! 445: ! 446: Routine Description: ! 447: ! 448: This routine completes the old write as well as getting ! 449: a pointer to the next write. ! 450: ! 451: The reason that we have have pointers to the current write ! 452: queue as well as the current write irp is so that this ! 453: routine may be used in the common completion code for ! 454: read and write. ! 455: ! 456: Arguments: ! 457: ! 458: CurrentOpIrp - Pointer to the pointer that points to the ! 459: current write irp. ! 460: ! 461: QueueToProcess - Pointer to the write queue. ! 462: ! 463: NewIrp - A pointer to a pointer to the irp that will be the ! 464: current irp. Note that this could end up pointing ! 465: to a null pointer. This does NOT necessaryly mean ! 466: that there is no current write. What could occur ! 467: is that while the cancel lock is held the write ! 468: queue ended up being empty, but as soon as we release ! 469: the cancel spin lock a new irp came in from ! 470: SerialStartWrite. ! 471: ! 472: CompleteCurrent - Flag indicates whether the CurrentOpIrp should ! 473: be completed. ! 474: ! 475: Return Value: ! 476: ! 477: None. ! 478: ! 479: --*/ ! 480: ! 481: { ! 482: ! 483: PSERIAL_DEVICE_EXTENSION Extension = CONTAINING_RECORD( ! 484: QueueToProcess, ! 485: SERIAL_DEVICE_EXTENSION, ! 486: WriteQueue ! 487: ); ! 488: ! 489: do { ! 490: ! 491: ! 492: // ! 493: // We could be completing a flush. ! 494: // ! 495: ! 496: if (IoGetCurrentIrpStackLocation(*CurrentOpIrp)->MajorFunction ! 497: == IRP_MJ_WRITE) { ! 498: ! 499: KIRQL OldIrql; ! 500: ! 501: ASSERT(Extension->TotalCharsQueued >= ! 502: (IoGetCurrentIrpStackLocation(*CurrentOpIrp) ! 503: ->Parameters.Write.Length)); ! 504: ! 505: IoAcquireCancelSpinLock(&OldIrql); ! 506: Extension->TotalCharsQueued -= ! 507: IoGetCurrentIrpStackLocation(*CurrentOpIrp) ! 508: ->Parameters.Write.Length; ! 509: IoReleaseCancelSpinLock(OldIrql); ! 510: ! 511: } else if (IoGetCurrentIrpStackLocation(*CurrentOpIrp)->MajorFunction ! 512: == IRP_MJ_DEVICE_CONTROL) { ! 513: ! 514: KIRQL OldIrql; ! 515: ! 516: IoAcquireCancelSpinLock(&OldIrql); ! 517: ! 518: // ! 519: // If CurrentXoffIrp is not equal to null, this ! 520: // implies that this is the "second" time around ! 521: // for this irp, which implies that we should really ! 522: // be completing it this time. ! 523: // ! 524: ! 525: if (Extension->CurrentXoffIrp) { ! 526: ! 527: Extension->CurrentXoffIrp = NULL; ! 528: IoReleaseCancelSpinLock(OldIrql); ! 529: ! 530: } else { ! 531: ! 532: PIRP Irp = *CurrentOpIrp; ! 533: ! 534: PSERIAL_XOFF_COUNTER Xc = Irp->AssociatedIrp.SystemBuffer; ! 535: ! 536: // ! 537: // We absolutely shouldn't have a cancel routine ! 538: // at this point. ! 539: // ! 540: ! 541: ASSERT(!Irp->CancelRoutine); ! 542: ! 543: // ! 544: // This could only be a xoff counter masquerading as ! 545: // a write irp. ! 546: // ! 547: ! 548: Extension->TotalCharsQueued--; ! 549: ! 550: // ! 551: // Check to see of the xoff irp has been set with success. ! 552: // This means that the write completed normally. If that ! 553: // is the case, and it hasn't been set to cancel in the ! 554: // meanwhile, then go on and make it the CurrentXoffIrp. ! 555: // ! 556: ! 557: if (Irp->IoStatus.Status != STATUS_SUCCESS) { ! 558: ! 559: // ! 560: // Oh well, we can just finish it off. ! 561: // ! 562: NOTHING; ! 563: ! 564: } else if (Irp->Cancel) { ! 565: ! 566: Irp->IoStatus.Status = STATUS_CANCELLED; ! 567: ! 568: } else { ! 569: ! 570: // ! 571: // Give it a new cancel routine, and increment the ! 572: // reference count because the cancel routine has ! 573: // a reference to it. ! 574: // ! 575: ! 576: IoSetCancelRoutine( ! 577: Irp, ! 578: SerialCancelCurrentXoff ! 579: ); ! 580: ! 581: SERIAL_INC_REFERENCE(Irp); ! 582: ! 583: // ! 584: // We don't want to complete the current irp now. This ! 585: // will now get completed by the Xoff counter code. ! 586: // ! 587: ! 588: CompleteCurrent = FALSE; ! 589: ! 590: // ! 591: // Give the counter to the isr. ! 592: // ! 593: ! 594: Extension->CurrentXoffIrp = Irp; ! 595: KeSynchronizeExecution( ! 596: Extension->Interrupt, ! 597: SerialGiveXoffToIsr, ! 598: Extension ! 599: ); ! 600: ! 601: // ! 602: // Start the timer for the counter and increment ! 603: // the reference count since the timer has a ! 604: // reference to the irp. ! 605: // ! 606: ! 607: if (Xc->Timeout) { ! 608: ! 609: KeSetTimer( ! 610: &Extension->XoffCountTimer, ! 611: RtlLargeIntegerNegate( ! 612: RtlEnlargedUnsignedMultiply( ! 613: 10000, ! 614: Xc->Timeout ! 615: ) ! 616: ), ! 617: &Extension->XoffCountTimeoutDpc ! 618: ); ! 619: ! 620: SERIAL_INC_REFERENCE(Irp); ! 621: ! 622: } ! 623: ! 624: } ! 625: ! 626: IoReleaseCancelSpinLock(OldIrql); ! 627: ! 628: } ! 629: ! 630: } ! 631: ! 632: // ! 633: // Note that the following call will (probably) also cause ! 634: // the current irp to be completed. ! 635: // ! 636: ! 637: SerialGetNextIrp( ! 638: CurrentOpIrp, ! 639: QueueToProcess, ! 640: NewIrp, ! 641: CompleteCurrent ! 642: ); ! 643: ! 644: if (!*NewIrp) { ! 645: ! 646: KIRQL OldIrql; ! 647: ! 648: IoAcquireCancelSpinLock(&OldIrql); ! 649: KeSynchronizeExecution( ! 650: Extension->Interrupt, ! 651: SerialProcessEmptyTransmit, ! 652: Extension ! 653: ); ! 654: IoReleaseCancelSpinLock(OldIrql); ! 655: ! 656: break; ! 657: ! 658: } else if (IoGetCurrentIrpStackLocation(*NewIrp)->MajorFunction ! 659: == IRP_MJ_FLUSH_BUFFERS) { ! 660: ! 661: // ! 662: // If we encounter a flush request we just want to get ! 663: // the next irp and complete the flush. ! 664: // ! 665: // Note that if NewIrp is non-null then it is also ! 666: // equal to CurrentWriteIrp. ! 667: // ! 668: ! 669: ! 670: ASSERT((*NewIrp) == (*CurrentOpIrp)); ! 671: (*NewIrp)->IoStatus.Status = STATUS_SUCCESS; ! 672: ! 673: } else { ! 674: ! 675: break; ! 676: ! 677: } ! 678: ! 679: } while (TRUE); ! 680: ! 681: } ! 682: ! 683: VOID ! 684: SerialCompleteWrite( ! 685: IN PKDPC Dpc, ! 686: IN PVOID DeferredContext, ! 687: IN PVOID SystemContext1, ! 688: IN PVOID SystemContext2 ! 689: ) ! 690: ! 691: /*++ ! 692: ! 693: Routine Description: ! 694: ! 695: This routine is merely used to complete any write. It ! 696: assumes that the status and the information fields of ! 697: the irp are already correctly filled in. ! 698: ! 699: Arguments: ! 700: ! 701: Dpc - Not Used. ! 702: ! 703: DeferredContext - Really points to the device extension. ! 704: ! 705: SystemContext1 - Not Used. ! 706: ! 707: SystemContext2 - Not Used. ! 708: ! 709: Return Value: ! 710: ! 711: None. ! 712: ! 713: --*/ ! 714: ! 715: { ! 716: ! 717: PSERIAL_DEVICE_EXTENSION Extension = DeferredContext; ! 718: KIRQL OldIrql; ! 719: ! 720: UNREFERENCED_PARAMETER(Dpc); ! 721: UNREFERENCED_PARAMETER(SystemContext1); ! 722: UNREFERENCED_PARAMETER(SystemContext2); ! 723: ! 724: IoAcquireCancelSpinLock(&OldIrql); ! 725: ! 726: SerialTryToCompleteCurrent( ! 727: Extension, ! 728: NULL, ! 729: OldIrql, ! 730: STATUS_SUCCESS, ! 731: &Extension->CurrentWriteIrp, ! 732: &Extension->WriteQueue, ! 733: NULL, ! 734: &Extension->WriteRequestTotalTimer, ! 735: SerialStartWrite, ! 736: SerialGetNextWrite ! 737: ); ! 738: ! 739: } ! 740: ! 741: BOOLEAN ! 742: SerialProcessEmptyTransmit( ! 743: IN PVOID Context ! 744: ) ! 745: ! 746: /*++ ! 747: ! 748: Routine Description: ! 749: ! 750: This routine is used to determine if conditions are appropriate ! 751: to satisfy a wait for transmit empty event, and if so to complete ! 752: the irp that is waiting for that event. It also call the code ! 753: that checks to see if we should lower the RTS line if we are ! 754: doing transmit toggling. ! 755: ! 756: NOTE: This routine is called by KeSynchronizeExecution. ! 757: ! 758: NOTE: This routine assumes that it is called with the cancel ! 759: spinlock held. ! 760: ! 761: Arguments: ! 762: ! 763: Context - Really a pointer to the device extension. ! 764: ! 765: Return Value: ! 766: ! 767: This routine always returns FALSE. ! 768: ! 769: --*/ ! 770: ! 771: { ! 772: ! 773: PSERIAL_DEVICE_EXTENSION Extension = Context; ! 774: ! 775: if (Extension->IsrWaitMask && (Extension->IsrWaitMask & SERIAL_EV_TXEMPTY) && ! 776: Extension->EmptiedTransmit && (!Extension->TransmitImmediate) && ! 777: (!Extension->CurrentWriteIrp) && IsListEmpty(&Extension->WriteQueue)) { ! 778: ! 779: Extension->HistoryMask |= SERIAL_EV_TXEMPTY; ! 780: if (Extension->IrpMaskLocation) { ! 781: ! 782: *Extension->IrpMaskLocation = Extension->HistoryMask; ! 783: Extension->IrpMaskLocation = NULL; ! 784: Extension->HistoryMask = 0; ! 785: ! 786: Extension->CurrentWaitIrp->IoStatus.Information = sizeof(ULONG); ! 787: KeInsertQueueDpc( ! 788: &Extension->CommWaitDpc, ! 789: NULL, ! 790: NULL ! 791: ); ! 792: ! 793: } ! 794: ! 795: Extension->CountOfTryingToLowerRTS++; ! 796: SerialPerhapsLowerRTS(Extension); ! 797: ! 798: } ! 799: ! 800: return FALSE; ! 801: ! 802: } ! 803: ! 804: BOOLEAN ! 805: SerialGiveWriteToIsr( ! 806: IN PVOID Context ! 807: ) ! 808: ! 809: /*++ ! 810: ! 811: Routine Description: ! 812: ! 813: Try to start off the write by slipping it in behind ! 814: a transmit immediate char, or if that isn't available ! 815: and the transmit holding register is empty, "tickle" ! 816: the UART into interrupting with a transmit buffer ! 817: empty. ! 818: ! 819: NOTE: This routine is called by KeSynchronizeExecution. ! 820: ! 821: NOTE: This routine assumes that it is called with the ! 822: cancel spin lock held. ! 823: ! 824: Arguments: ! 825: ! 826: Context - Really a pointer to the device extension. ! 827: ! 828: Return Value: ! 829: ! 830: This routine always returns FALSE. ! 831: ! 832: --*/ ! 833: ! 834: { ! 835: ! 836: PSERIAL_DEVICE_EXTENSION Extension = Context; ! 837: ! 838: // ! 839: // The current stack location. This contains all of the ! 840: // information we need to process this particular request. ! 841: // ! 842: PIO_STACK_LOCATION IrpSp; ! 843: ! 844: IrpSp = IoGetCurrentIrpStackLocation(Extension->CurrentWriteIrp); ! 845: ! 846: // ! 847: // We might have a xoff counter request masquerading as a ! 848: // write. The length of these requests will always be one ! 849: // and we can get a pointer to the actual character from ! 850: // the data supplied by the user. ! 851: // ! 852: ! 853: if (IrpSp->MajorFunction == IRP_MJ_WRITE) { ! 854: ! 855: Extension->WriteLength = IrpSp->Parameters.Write.Length; ! 856: Extension->WriteCurrentChar = ! 857: Extension->CurrentWriteIrp->AssociatedIrp.SystemBuffer; ! 858: ! 859: } else { ! 860: ! 861: Extension->WriteLength = 1; ! 862: Extension->WriteCurrentChar = ! 863: ((PUCHAR)Extension->CurrentWriteIrp->AssociatedIrp.SystemBuffer) + ! 864: FIELD_OFFSET( ! 865: SERIAL_XOFF_COUNTER, ! 866: XoffChar ! 867: ); ! 868: ! 869: } ! 870: ! 871: // ! 872: // The isr now has a reference to the irp. ! 873: // ! 874: ! 875: SERIAL_INC_REFERENCE(Extension->CurrentWriteIrp); ! 876: ! 877: // ! 878: // Check first to see if an immediate char is transmitting. ! 879: // If it is then we'll just slip in behind it when its ! 880: // done. ! 881: // ! 882: ! 883: if (!Extension->TransmitImmediate) { ! 884: ! 885: // ! 886: // If there is no immediate char transmitting then we ! 887: // will "re-enable" the transmit holding register empty ! 888: // interrupt. The 8250 family of devices will always ! 889: // signal a transmit holding register empty interrupt ! 890: // *ANY* time this bit is set to one. By doing things ! 891: // this way we can simply use the normal interrupt code ! 892: // to start off this write. ! 893: // ! 894: // We've been keeping track of whether the transmit holding ! 895: // register is empty so it we only need to do this ! 896: // if the register is empty. ! 897: // ! 898: ! 899: if (Extension->HoldingEmpty) { ! 900: ! 901: DISABLE_ALL_INTERRUPTS(Extension->Controller); ! 902: ENABLE_ALL_INTERRUPTS(Extension->Controller); ! 903: ! 904: } ! 905: ! 906: } ! 907: ! 908: // ! 909: // The rts line may already be up from previous writes, ! 910: // however, it won't take much additional time to turn ! 911: // on the RTS line if we are doing transmit toggling. ! 912: // ! 913: ! 914: if ((Extension->HandFlow.FlowReplace & SERIAL_RTS_MASK) == ! 915: SERIAL_TRANSMIT_TOGGLE) { ! 916: ! 917: SerialSetRTS(Extension); ! 918: ! 919: } ! 920: ! 921: return FALSE; ! 922: ! 923: } ! 924: ! 925: VOID ! 926: SerialCancelCurrentWrite( ! 927: PDEVICE_OBJECT DeviceObject, ! 928: PIRP Irp ! 929: ) ! 930: ! 931: /*++ ! 932: ! 933: Routine Description: ! 934: ! 935: This routine is used to cancel the current write. ! 936: ! 937: Arguments: ! 938: ! 939: DeviceObject - Pointer to the device object for this device ! 940: ! 941: Irp - Pointer to the IRP to be canceled. ! 942: ! 943: Return Value: ! 944: ! 945: None. ! 946: ! 947: --*/ ! 948: ! 949: { ! 950: ! 951: PSERIAL_DEVICE_EXTENSION Extension = DeviceObject->DeviceExtension; ! 952: ! 953: SerialTryToCompleteCurrent( ! 954: Extension, ! 955: SerialGrabWriteFromIsr, ! 956: Irp->CancelIrql, ! 957: STATUS_CANCELLED, ! 958: &Extension->CurrentWriteIrp, ! 959: &Extension->WriteQueue, ! 960: NULL, ! 961: &Extension->WriteRequestTotalTimer, ! 962: SerialStartWrite, ! 963: SerialGetNextWrite ! 964: ); ! 965: ! 966: } ! 967: ! 968: VOID ! 969: SerialWriteTimeout( ! 970: IN PKDPC Dpc, ! 971: IN PVOID DeferredContext, ! 972: IN PVOID SystemContext1, ! 973: IN PVOID SystemContext2 ! 974: ) ! 975: ! 976: /*++ ! 977: ! 978: Routine Description: ! 979: ! 980: This routine will try to timeout the current write. ! 981: ! 982: Arguments: ! 983: ! 984: Dpc - Not Used. ! 985: ! 986: DeferredContext - Really points to the device extension. ! 987: ! 988: SystemContext1 - Not Used. ! 989: ! 990: SystemContext2 - Not Used. ! 991: ! 992: Return Value: ! 993: ! 994: None. ! 995: ! 996: --*/ ! 997: ! 998: { ! 999: ! 1000: PSERIAL_DEVICE_EXTENSION Extension = DeferredContext; ! 1001: KIRQL OldIrql; ! 1002: ! 1003: UNREFERENCED_PARAMETER(Dpc); ! 1004: UNREFERENCED_PARAMETER(SystemContext1); ! 1005: UNREFERENCED_PARAMETER(SystemContext2); ! 1006: ! 1007: IoAcquireCancelSpinLock(&OldIrql); ! 1008: ! 1009: SerialTryToCompleteCurrent( ! 1010: Extension, ! 1011: SerialGrabWriteFromIsr, ! 1012: OldIrql, ! 1013: STATUS_TIMEOUT, ! 1014: &Extension->CurrentWriteIrp, ! 1015: &Extension->WriteQueue, ! 1016: NULL, ! 1017: &Extension->WriteRequestTotalTimer, ! 1018: SerialStartWrite, ! 1019: SerialGetNextWrite ! 1020: ); ! 1021: ! 1022: } ! 1023: ! 1024: BOOLEAN ! 1025: SerialGrabWriteFromIsr( ! 1026: IN PVOID Context ! 1027: ) ! 1028: ! 1029: /*++ ! 1030: ! 1031: Routine Description: ! 1032: ! 1033: ! 1034: This routine is used to grab the current irp, which could be timing ! 1035: out or canceling, from the ISR ! 1036: ! 1037: NOTE: This routine is being called from KeSynchronizeExecution. ! 1038: ! 1039: NOTE: This routine assumes that the cancel spin lock is held ! 1040: when this routine is called. ! 1041: ! 1042: Arguments: ! 1043: ! 1044: Context - Really a pointer to the device extension. ! 1045: ! 1046: Return Value: ! 1047: ! 1048: Always false. ! 1049: ! 1050: --*/ ! 1051: ! 1052: { ! 1053: ! 1054: PSERIAL_DEVICE_EXTENSION Extension = Context; ! 1055: ! 1056: // ! 1057: // Check if the write length is non-zero. If it is non-zero ! 1058: // then the ISR still owns the irp. We calculate the the number ! 1059: // of characters written and update the information field of the ! 1060: // irp with the characters written. We then clear the write length ! 1061: // the isr sees. ! 1062: // ! 1063: ! 1064: if (Extension->WriteLength) { ! 1065: ! 1066: // ! 1067: // We could have an xoff counter masquerading as a ! 1068: // write irp. If so, don't update the write length. ! 1069: // ! 1070: ! 1071: if (IoGetCurrentIrpStackLocation(Extension->CurrentWriteIrp) ! 1072: ->MajorFunction == IRP_MJ_WRITE) { ! 1073: ! 1074: Extension->CurrentWriteIrp->IoStatus.Information = ! 1075: IoGetCurrentIrpStackLocation( ! 1076: Extension->CurrentWriteIrp ! 1077: )->Parameters.Write.Length - ! 1078: Extension->WriteLength; ! 1079: ! 1080: } else { ! 1081: ! 1082: Extension->CurrentWriteIrp->IoStatus.Information = 0; ! 1083: ! 1084: } ! 1085: ! 1086: // ! 1087: // Since the isr no longer references this irp, we can ! 1088: // decrement it's reference count. ! 1089: // ! 1090: ! 1091: SERIAL_DEC_REFERENCE(Extension->CurrentWriteIrp); ! 1092: ! 1093: Extension->WriteLength = 0; ! 1094: ! 1095: } ! 1096: ! 1097: return FALSE; ! 1098: ! 1099: } ! 1100: ! 1101: BOOLEAN ! 1102: SerialGrabXoffFromIsr( ! 1103: IN PVOID Context ! 1104: ) ! 1105: ! 1106: /*++ ! 1107: ! 1108: Routine Description: ! 1109: ! 1110: This routine is used to grab an xoff counter irp from the ! 1111: isr when it is no longer masquerading as a write irp. This ! 1112: routine is called by the cancel and timeout code for the ! 1113: xoff counter ioctl. ! 1114: ! 1115: ! 1116: NOTE: This routine is being called from KeSynchronizeExecution. ! 1117: ! 1118: NOTE: This routine assumes that the cancel spin lock is held ! 1119: when this routine is called. ! 1120: ! 1121: Arguments: ! 1122: ! 1123: Context - Really a pointer to the device extension. ! 1124: ! 1125: Return Value: ! 1126: ! 1127: Always false. ! 1128: ! 1129: --*/ ! 1130: ! 1131: { ! 1132: ! 1133: PSERIAL_DEVICE_EXTENSION Extension = Context; ! 1134: ! 1135: if (Extension->CountSinceXoff) { ! 1136: ! 1137: // ! 1138: // This is only non-zero when there actually is a Xoff ioctl ! 1139: // counting down. ! 1140: // ! 1141: ! 1142: Extension->CountSinceXoff = 0; ! 1143: ! 1144: // ! 1145: // We decrement the count since the isr no longer owns ! 1146: // the irp. ! 1147: // ! 1148: ! 1149: SERIAL_DEC_REFERENCE(Extension->CurrentXoffIrp); ! 1150: ! 1151: } ! 1152: ! 1153: return FALSE; ! 1154: ! 1155: } ! 1156: ! 1157: VOID ! 1158: SerialCompleteXoff( ! 1159: IN PKDPC Dpc, ! 1160: IN PVOID DeferredContext, ! 1161: IN PVOID SystemContext1, ! 1162: IN PVOID SystemContext2 ! 1163: ) ! 1164: ! 1165: /*++ ! 1166: ! 1167: Routine Description: ! 1168: ! 1169: This routine is merely used to truely complete an xoff counter irp. It ! 1170: assumes that the status and the information fields of the irp are ! 1171: already correctly filled in. ! 1172: ! 1173: Arguments: ! 1174: ! 1175: Dpc - Not Used. ! 1176: ! 1177: DeferredContext - Really points to the device extension. ! 1178: ! 1179: SystemContext1 - Not Used. ! 1180: ! 1181: SystemContext2 - Not Used. ! 1182: ! 1183: Return Value: ! 1184: ! 1185: None. ! 1186: ! 1187: --*/ ! 1188: ! 1189: { ! 1190: ! 1191: PSERIAL_DEVICE_EXTENSION Extension = DeferredContext; ! 1192: KIRQL OldIrql; ! 1193: ! 1194: UNREFERENCED_PARAMETER(Dpc); ! 1195: UNREFERENCED_PARAMETER(SystemContext1); ! 1196: UNREFERENCED_PARAMETER(SystemContext2); ! 1197: ! 1198: IoAcquireCancelSpinLock(&OldIrql); ! 1199: ! 1200: // ! 1201: // Turn this irp back into the current write irp so ! 1202: // that it will start of any writes behind it. ! 1203: // ! 1204: ! 1205: Extension->CurrentWriteIrp = Extension->CurrentXoffIrp; ! 1206: ! 1207: SerialTryToCompleteCurrent( ! 1208: Extension, ! 1209: NULL, ! 1210: OldIrql, ! 1211: STATUS_SUCCESS, ! 1212: &Extension->CurrentWriteIrp, ! 1213: &Extension->WriteQueue, ! 1214: NULL, ! 1215: &Extension->XoffCountTimer, ! 1216: SerialStartWrite, ! 1217: SerialGetNextWrite ! 1218: ); ! 1219: ! 1220: } ! 1221: ! 1222: VOID ! 1223: SerialTimeoutXoff( ! 1224: IN PKDPC Dpc, ! 1225: IN PVOID DeferredContext, ! 1226: IN PVOID SystemContext1, ! 1227: IN PVOID SystemContext2 ! 1228: ) ! 1229: ! 1230: /*++ ! 1231: ! 1232: Routine Description: ! 1233: ! 1234: This routine is merely used to truely complete an xoff counter irp, ! 1235: if its timer has run out. ! 1236: ! 1237: Arguments: ! 1238: ! 1239: Dpc - Not Used. ! 1240: ! 1241: DeferredContext - Really points to the device extension. ! 1242: ! 1243: SystemContext1 - Not Used. ! 1244: ! 1245: SystemContext2 - Not Used. ! 1246: ! 1247: Return Value: ! 1248: ! 1249: None. ! 1250: ! 1251: --*/ ! 1252: ! 1253: { ! 1254: ! 1255: PSERIAL_DEVICE_EXTENSION Extension = DeferredContext; ! 1256: KIRQL OldIrql; ! 1257: ! 1258: UNREFERENCED_PARAMETER(Dpc); ! 1259: UNREFERENCED_PARAMETER(SystemContext1); ! 1260: UNREFERENCED_PARAMETER(SystemContext2); ! 1261: ! 1262: IoAcquireCancelSpinLock(&OldIrql); ! 1263: ! 1264: // ! 1265: // Turn this irp back into the current write irp so ! 1266: // that it will start of any writes behind it. ! 1267: // ! 1268: ! 1269: Extension->CurrentWriteIrp = Extension->CurrentXoffIrp; ! 1270: ! 1271: SerialTryToCompleteCurrent( ! 1272: Extension, ! 1273: SerialGrabXoffFromIsr, ! 1274: OldIrql, ! 1275: STATUS_SERIAL_COUNTER_TIMEOUT, ! 1276: &Extension->CurrentWriteIrp, ! 1277: &Extension->WriteQueue, ! 1278: NULL, ! 1279: &Extension->XoffCountTimer, ! 1280: SerialStartWrite, ! 1281: SerialGetNextWrite ! 1282: ); ! 1283: ! 1284: } ! 1285: ! 1286: VOID ! 1287: SerialCancelCurrentXoff( ! 1288: PDEVICE_OBJECT DeviceObject, ! 1289: PIRP Irp ! 1290: ) ! 1291: ! 1292: /*++ ! 1293: ! 1294: Routine Description: ! 1295: ! 1296: This routine is used to cancel the current write. ! 1297: ! 1298: Arguments: ! 1299: ! 1300: DeviceObject - Pointer to the device object for this device ! 1301: ! 1302: Irp - Pointer to the IRP to be canceled. ! 1303: ! 1304: Return Value: ! 1305: ! 1306: None. ! 1307: ! 1308: --*/ ! 1309: ! 1310: { ! 1311: ! 1312: PSERIAL_DEVICE_EXTENSION Extension = DeviceObject->DeviceExtension; ! 1313: ! 1314: // ! 1315: // Turn this irp back into the current write irp so ! 1316: // that it will start of any writes behind it. ! 1317: // ! 1318: ! 1319: Extension->CurrentWriteIrp = Extension->CurrentXoffIrp; ! 1320: ! 1321: SerialTryToCompleteCurrent( ! 1322: Extension, ! 1323: SerialGrabXoffFromIsr, ! 1324: Irp->CancelIrql, ! 1325: STATUS_CANCELLED, ! 1326: &Extension->CurrentWriteIrp, ! 1327: &Extension->WriteQueue, ! 1328: NULL, ! 1329: &Extension->XoffCountTimer, ! 1330: SerialStartWrite, ! 1331: SerialGetNextWrite ! 1332: ); ! 1333: ! 1334: } ! 1335: ! 1336: BOOLEAN ! 1337: SerialGiveXoffToIsr( ! 1338: IN PVOID Context ! 1339: ) ! 1340: ! 1341: /*++ ! 1342: ! 1343: Routine Description: ! 1344: ! 1345: ! 1346: This routine starts off the xoff counter. It merely ! 1347: has to set the xoff count and increment the reference ! 1348: count to denote that the isr has a reference to the irp. ! 1349: ! 1350: NOTE: This routine is called by KeSynchronizeExecution. ! 1351: ! 1352: NOTE: This routine assumes that it is called with the ! 1353: cancel spin lock held. ! 1354: ! 1355: Arguments: ! 1356: ! 1357: Context - Really a pointer to the device extension. ! 1358: ! 1359: Return Value: ! 1360: ! 1361: This routine always returns FALSE. ! 1362: ! 1363: --*/ ! 1364: ! 1365: { ! 1366: ! 1367: PSERIAL_DEVICE_EXTENSION Extension = Context; ! 1368: ! 1369: // ! 1370: // The current stack location. This contains all of the ! 1371: // information we need to process this particular request. ! 1372: // ! 1373: PSERIAL_XOFF_COUNTER Xc = ! 1374: Extension->CurrentXoffIrp->AssociatedIrp.SystemBuffer; ! 1375: ! 1376: Extension->CountSinceXoff = Xc->Counter; ! 1377: ! 1378: // ! 1379: // The isr now has a reference to the irp. ! 1380: // ! 1381: ! 1382: SERIAL_INC_REFERENCE(Extension->CurrentXoffIrp); ! 1383: ! 1384: return FALSE; ! 1385: ! 1386: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.