![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to openclos.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 openclos.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: openclos.c ! 8: ! 9: Abstract: ! 10: ! 11: This module contains the code that is very specific to ! 12: opening, closing, and cleaning up 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: BOOLEAN ! 34: SerialMarkOpen( ! 35: IN PVOID Context ! 36: ); ! 37: ! 38: BOOLEAN ! 39: SerialCheckOpen( ! 40: IN PVOID Context ! 41: ); ! 42: ! 43: typedef struct _SERIAL_CHECK_OPEN { ! 44: PSERIAL_DEVICE_EXTENSION Extension; ! 45: NTSTATUS *StatusOfOpen; ! 46: } SERIAL_CHECK_OPEN,*PSERIAL_CHECK_OPEN; ! 47: ! 48: // ! 49: // Just a bogus little routine to make sure that we ! 50: // can synch with the ISR. ! 51: // ! 52: BOOLEAN ! 53: SerialNullSynch( ! 54: IN PVOID Context ! 55: ) { ! 56: ! 57: UNREFERENCED_PARAMETER(Context); ! 58: return FALSE; ! 59: } ! 60: ! 61: NTSTATUS ! 62: SerialCreateOpen( ! 63: IN PDEVICE_OBJECT DeviceObject, ! 64: IN PIRP Irp ! 65: ) ! 66: ! 67: /*++ ! 68: ! 69: Routine Description: ! 70: ! 71: We connect up to the interrupt for the create/open and initialize ! 72: the structures needed to maintain an open for a device. ! 73: ! 74: Arguments: ! 75: ! 76: DeviceObject - Pointer to the device object for this device ! 77: ! 78: Irp - Pointer to the IRP for the current request ! 79: ! 80: Return Value: ! 81: ! 82: The function value is the final status of the call ! 83: ! 84: --*/ ! 85: ! 86: { ! 87: ! 88: PSERIAL_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension; ! 89: SERIAL_CHECK_OPEN checkOpen; ! 90: NTSTATUS localStatus; ! 91: ! 92: SerialDump( ! 93: SERIRPPATH, ! 94: ("SERIAL: Dispatch entry for: %x\n",Irp) ! 95: ); ! 96: SerialDump( ! 97: SERDIAG3, ! 98: ("SERIAL: In SerialCreateOpen\n") ! 99: ); ! 100: ! 101: // ! 102: // Before we do anything, let's make sure they aren't trying ! 103: // to create a directory. This is a silly, but what's a driver to do!? ! 104: // ! 105: ! 106: if (IoGetCurrentIrpStackLocation(Irp)->Parameters.Create.Options & ! 107: FILE_DIRECTORY_FILE) { ! 108: ! 109: Irp->IoStatus.Status = STATUS_NOT_A_DIRECTORY; ! 110: Irp->IoStatus.Information = 0; ! 111: ! 112: SerialDump( ! 113: SERIRPPATH, ! 114: ("SERIAL: Complete Irp: %x\n",Irp) ! 115: ); ! 116: IoCompleteRequest( ! 117: Irp, ! 118: IO_NO_INCREMENT ! 119: ); ! 120: return STATUS_NOT_A_DIRECTORY; ! 121: ! 122: } ! 123: ! 124: // ! 125: // Create a buffer for the RX data when no reads are outstanding. ! 126: // ! 127: ! 128: extension->InterruptReadBuffer = NULL; ! 129: extension->BufferSize = 0; ! 130: ! 131: switch (MmQuerySystemSize()) { ! 132: ! 133: case MmLargeSystem: { ! 134: ! 135: extension->BufferSize = 4096; ! 136: extension->InterruptReadBuffer = ExAllocatePool( ! 137: NonPagedPool, ! 138: extension->BufferSize ! 139: ); ! 140: ! 141: if (extension->InterruptReadBuffer) { ! 142: ! 143: break; ! 144: ! 145: } ! 146: ! 147: } ! 148: ! 149: case MmMediumSystem: { ! 150: ! 151: extension->BufferSize = 1024; ! 152: extension->InterruptReadBuffer = ExAllocatePool( ! 153: NonPagedPool, ! 154: extension->BufferSize ! 155: ); ! 156: ! 157: if (extension->InterruptReadBuffer) { ! 158: ! 159: break; ! 160: ! 161: } ! 162: ! 163: } ! 164: ! 165: case MmSmallSystem: { ! 166: ! 167: extension->BufferSize = 128; ! 168: extension->InterruptReadBuffer = ExAllocatePool( ! 169: NonPagedPool, ! 170: extension->BufferSize ! 171: ); ! 172: ! 173: } ! 174: ! 175: } ! 176: ! 177: if (!extension->InterruptReadBuffer) { ! 178: ! 179: extension->BufferSize = 0; ! 180: Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; ! 181: Irp->IoStatus.Information = 0; ! 182: ! 183: SerialDump( ! 184: SERIRPPATH, ! 185: ("SERIAL: Complete Irp: %x\n",Irp) ! 186: ); ! 187: IoCompleteRequest( ! 188: Irp, ! 189: IO_NO_INCREMENT ! 190: ); ! 191: return STATUS_INSUFFICIENT_RESOURCES; ! 192: ! 193: } ! 194: ! 195: // ! 196: // On a new open we "flush" the read queue by initializing the ! 197: // count of characters. ! 198: // ! 199: ! 200: extension->CharsInInterruptBuffer = 0; ! 201: extension->LastCharSlot = extension->InterruptReadBuffer + ! 202: (extension->BufferSize - 1); ! 203: ! 204: extension->ReadBufferBase = extension->InterruptReadBuffer; ! 205: extension->CurrentCharSlot = extension->InterruptReadBuffer; ! 206: extension->FirstReadableChar = extension->InterruptReadBuffer; ! 207: ! 208: extension->TotalCharsQueued = 0; ! 209: ! 210: // ! 211: // We set up the default xon/xoff limits. ! 212: // ! 213: ! 214: extension->HandFlow.XoffLimit = extension->BufferSize >> 3; ! 215: extension->HandFlow.XonLimit = extension->BufferSize >> 1; ! 216: ! 217: extension->BufferSizePt8 = ((3*(extension->BufferSize>>2))+ ! 218: (extension->BufferSize>>4)); ! 219: ! 220: extension->IrpMaskLocation = NULL; ! 221: extension->HistoryMask = 0; ! 222: extension->IsrWaitMask = 0; ! 223: ! 224: extension->SendXonChar = FALSE; ! 225: extension->SendXoffChar = FALSE; ! 226: ! 227: // ! 228: // The escape char replacement must be reset upon every open. ! 229: // ! 230: ! 231: extension->EscapeChar = 0; ! 232: ! 233: #if !defined(SERIAL_CRAZY_INTERRUPTS) ! 234: ! 235: if (!extension->InterruptShareable) { ! 236: ! 237: checkOpen.Extension = extension; ! 238: checkOpen.StatusOfOpen = &Irp->IoStatus.Status; ! 239: ! 240: KeSynchronizeExecution( ! 241: extension->Interrupt, ! 242: SerialCheckOpen, ! 243: &checkOpen ! 244: ); ! 245: ! 246: } else { ! 247: ! 248: KeSynchronizeExecution( ! 249: extension->Interrupt, ! 250: SerialMarkOpen, ! 251: extension ! 252: ); ! 253: ! 254: Irp->IoStatus.Status = STATUS_SUCCESS; ! 255: ! 256: } ! 257: #else ! 258: ! 259: // ! 260: // Synchronize with the ISR and let it know that the device ! 261: // has been successfully opened. ! 262: // ! 263: ! 264: KeSynchronizeExecution( ! 265: extension->Interrupt, ! 266: SerialMarkOpen, ! 267: extension ! 268: ); ! 269: ! 270: Irp->IoStatus.Status = STATUS_SUCCESS; ! 271: #endif ! 272: ! 273: localStatus = Irp->IoStatus.Status; ! 274: Irp->IoStatus.Information=0L; ! 275: ! 276: SerialDump( ! 277: SERIRPPATH, ! 278: ("SERIAL: Complete Irp: %x\n",Irp) ! 279: ); ! 280: IoCompleteRequest( ! 281: Irp, ! 282: IO_NO_INCREMENT ! 283: ); ! 284: ! 285: return localStatus; ! 286: ! 287: } ! 288: ! 289: NTSTATUS ! 290: SerialClose( ! 291: IN PDEVICE_OBJECT DeviceObject, ! 292: IN PIRP Irp ! 293: ) ! 294: ! 295: /*++ ! 296: ! 297: Routine Description: ! 298: ! 299: We simpley disconnect the interrupt for now. ! 300: ! 301: Arguments: ! 302: ! 303: DeviceObject - Pointer to the device object for this device ! 304: ! 305: Irp - Pointer to the IRP for the current request ! 306: ! 307: Return Value: ! 308: ! 309: The function value is the final status of the call ! 310: ! 311: --*/ ! 312: ! 313: { ! 314: ! 315: // ! 316: // This "timer value" is used to wait 10 character times ! 317: // after the hardware is empty before we actually "run down" ! 318: // all of the flow control/break junk. ! 319: // ! 320: LARGE_INTEGER tenCharDelay; ! 321: ! 322: // ! 323: // Holds a character time. ! 324: // ! 325: LARGE_INTEGER charTime; ! 326: ! 327: // ! 328: // Just what it says. This is the serial specific device ! 329: // extension of the device object create for the serial driver. ! 330: // ! 331: PSERIAL_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension; ! 332: ! 333: SerialDump( ! 334: SERIRPPATH, ! 335: ("SERIAL: Dispatch entry for: %x\n",Irp) ! 336: ); ! 337: SerialDump( ! 338: SERDIAG3, ! 339: ("SERIAL: In SerialClose\n") ! 340: ); ! 341: ! 342: charTime = RtlLargeIntegerNegate(SerialGetCharTime(extension)); ! 343: ! 344: // ! 345: // Synchronize with the ISR to let it know that interrupts are ! 346: // no longer important. ! 347: // ! 348: ! 349: KeSynchronizeExecution( ! 350: extension->Interrupt, ! 351: SerialMarkClose, ! 352: extension ! 353: ); ! 354: ! 355: // ! 356: // Synchronize with the isr to turn off break if it ! 357: // is already on. ! 358: // ! 359: ! 360: KeSynchronizeExecution( ! 361: extension->Interrupt, ! 362: SerialTurnOffBreak, ! 363: extension ! 364: ); ! 365: ! 366: // ! 367: // If the driver has automatically transmitted an Xoff in ! 368: // the context of automatic receive flow control then we ! 369: // should transmit an Xon. ! 370: // ! 371: ! 372: if (extension->RXHolding & SERIAL_RX_XOFF) { ! 373: ! 374: // ! 375: // Loop until the holding register is empty. ! 376: // ! 377: ! 378: while (!(READ_LINE_STATUS(extension->Controller) & ! 379: SERIAL_LSR_THRE)) { ! 380: ! 381: KeDelayExecutionThread( ! 382: KernelMode, ! 383: FALSE, ! 384: &charTime ! 385: ); ! 386: ! 387: } ! 388: ! 389: WRITE_TRANSMIT_HOLDING( ! 390: extension->Controller, ! 391: extension->SpecialChars.XonChar ! 392: ); ! 393: ! 394: } ! 395: ! 396: // ! 397: // Wait until all characters have been emptied out of the hardware. ! 398: // ! 399: ! 400: while ((READ_LINE_STATUS(extension->Controller) & ! 401: (SERIAL_LSR_THRE | SERIAL_LSR_TEMT)) != ! 402: (SERIAL_LSR_THRE | SERIAL_LSR_TEMT)) { ! 403: ! 404: KeDelayExecutionThread( ! 405: KernelMode, ! 406: FALSE, ! 407: &charTime ! 408: ); ! 409: ! 410: } ! 411: ! 412: // ! 413: // The hardware is empty. Delay 10 character times before ! 414: // shut down all the flow control. ! 415: // ! 416: ! 417: tenCharDelay = RtlExtendedIntegerMultiply( ! 418: charTime, ! 419: 10 ! 420: ); ! 421: ! 422: KeDelayExecutionThread( ! 423: KernelMode, ! 424: TRUE, ! 425: &tenCharDelay ! 426: ); ! 427: ! 428: SerialClrDTR(extension); ! 429: ! 430: // ! 431: // We have to be very careful how we clear the RTS line. ! 432: // Transmit toggling might have been on at some point. ! 433: // ! 434: // We know that there is nothing left that could start ! 435: // out the "polling" execution path. We need to ! 436: // check the counter that indicates that the execution ! 437: // path is active. If it is then we loop delaying one ! 438: // character time. After each delay we check to see if ! 439: // the counter has gone to zero. When it has we know that ! 440: // the execution path should be just about finished. We ! 441: // make sure that we still aren't in the routine that ! 442: // synchronized execution with the ISR by synchronizing ! 443: // ourselve with the ISR. ! 444: // ! 445: ! 446: if (extension->CountOfTryingToLowerRTS) { ! 447: ! 448: do { ! 449: ! 450: KeDelayExecutionThread( ! 451: KernelMode, ! 452: FALSE, ! 453: &charTime ! 454: ); ! 455: ! 456: } while (extension->CountOfTryingToLowerRTS); ! 457: ! 458: KeSynchronizeExecution( ! 459: extension->Interrupt, ! 460: SerialNullSynch, ! 461: NULL ! 462: ); ! 463: ! 464: // ! 465: // The execution path should no longer exist that ! 466: // is trying to push down the RTS. Well just ! 467: // make sure it's down by falling through to ! 468: // code that forces it down. ! 469: // ! 470: ! 471: } ! 472: ! 473: SerialClrRTS(extension); ! 474: ! 475: // ! 476: // Clean out the holding reasons (since we are closed). ! 477: // ! 478: ! 479: extension->RXHolding = 0; ! 480: extension->TXHolding = 0; ! 481: ! 482: // ! 483: // All is done. The port has been disabled from interrupting ! 484: // so there is no point in keeping the memory around. ! 485: // ! 486: ! 487: extension->BufferSize = 0; ! 488: ExFreePool(extension->InterruptReadBuffer); ! 489: extension->InterruptReadBuffer = NULL; ! 490: ! 491: Irp->IoStatus.Status = STATUS_SUCCESS; ! 492: Irp->IoStatus.Information=0L; ! 493: ! 494: SerialDump( ! 495: SERIRPPATH, ! 496: ("SERIAL: Complete Irp: %x\n",Irp) ! 497: ); ! 498: IoCompleteRequest( ! 499: Irp, ! 500: IO_NO_INCREMENT ! 501: ); ! 502: ! 503: return STATUS_SUCCESS; ! 504: ! 505: } ! 506: ! 507: BOOLEAN ! 508: SerialCheckOpen( ! 509: IN PVOID Context ! 510: ) ! 511: ! 512: /*++ ! 513: ! 514: Routine Description: ! 515: ! 516: This routine will traverse the circular doubly linked list ! 517: of devices that are using the same interrupt object. It will look ! 518: for other devices that are open. If it doesn't find any ! 519: it will indicate that it is ok to open this device. ! 520: ! 521: If it finds another device open we have two cases: ! 522: ! 523: 1) The device we are trying to open is on a multiport card. ! 524: ! 525: If the already open device is part of a multiport device ! 526: this code will indicate it is ok to open. We do this on the ! 527: theory that the multiport devices are daisy chained ! 528: and the cards can correctly arbitrate the interrupt ! 529: line. Note this assumption could be wrong. Somebody ! 530: could put two non-daisychained multiports on the ! 531: same interrupt. However, only a total clod would do ! 532: such a thing, and in my opinion deserves everthing they ! 533: get. ! 534: ! 535: 2) The device we are trying to open is not on a multiport card. ! 536: ! 537: We indicate that it is not ok to open. ! 538: ! 539: Arguments: ! 540: ! 541: Context - This is a structure that contains a pointer to the ! 542: extension of the device we are trying to open, and ! 543: a pointer to an NTSTATUS that will indicate whether ! 544: the device was opened or not. ! 545: ! 546: Return Value: ! 547: ! 548: This routine always returns FALSE. ! 549: ! 550: --*/ ! 551: ! 552: { ! 553: ! 554: PSERIAL_DEVICE_EXTENSION extensionToOpen = ! 555: ((PSERIAL_CHECK_OPEN)Context)->Extension; ! 556: NTSTATUS *status = ((PSERIAL_CHECK_OPEN)Context)->StatusOfOpen; ! 557: PLIST_ENTRY firstEntry = &extensionToOpen->CommonInterruptObject; ! 558: PLIST_ENTRY currentEntry = firstEntry; ! 559: PSERIAL_DEVICE_EXTENSION currentExtension; ! 560: ! 561: do { ! 562: ! 563: currentExtension = CONTAINING_RECORD( ! 564: currentEntry, ! 565: SERIAL_DEVICE_EXTENSION, ! 566: CommonInterruptObject ! 567: ); ! 568: ! 569: if (currentExtension->DeviceIsOpened) { ! 570: ! 571: break; ! 572: ! 573: } ! 574: ! 575: currentEntry = currentExtension->CommonInterruptObject.Flink; ! 576: ! 577: } while (currentEntry != firstEntry); ! 578: ! 579: if (currentEntry == firstEntry) { ! 580: ! 581: // ! 582: // We searched the whole list and found no other opens ! 583: // mark the status as successful and call the regular ! 584: // opening routine. ! 585: // ! 586: ! 587: *status = STATUS_SUCCESS; ! 588: SerialMarkOpen(extensionToOpen); ! 589: ! 590: } else { ! 591: ! 592: if (!extensionToOpen->PortOnAMultiportCard) { ! 593: ! 594: *status = STATUS_SHARED_IRQ_BUSY; ! 595: ! 596: } else { ! 597: ! 598: if (!currentExtension->PortOnAMultiportCard) { ! 599: ! 600: *status = STATUS_SHARED_IRQ_BUSY; ! 601: ! 602: } else { ! 603: ! 604: *status = STATUS_SUCCESS; ! 605: SerialMarkOpen(extensionToOpen); ! 606: ! 607: } ! 608: ! 609: } ! 610: ! 611: } ! 612: ! 613: return FALSE; ! 614: ! 615: } ! 616: ! 617: BOOLEAN ! 618: SerialMarkOpen( ! 619: IN PVOID Context ! 620: ) ! 621: ! 622: /*++ ! 623: ! 624: Routine Description: ! 625: ! 626: This routine merely sets a boolean to true to mark the fact that ! 627: somebody opened the device and its worthwhile to pay attention ! 628: to interrupts. ! 629: ! 630: Arguments: ! 631: ! 632: Context - Really a pointer to the device extension. ! 633: ! 634: Return Value: ! 635: ! 636: This routine always returns FALSE. ! 637: ! 638: --*/ ! 639: ! 640: { ! 641: ! 642: PSERIAL_DEVICE_EXTENSION extension = Context; ! 643: ! 644: SerialReset(extension); ! 645: ! 646: // ! 647: // Prepare for the opening by re-enabling interrupts. ! 648: // ! 649: // We do this my modifying the OUT2 line in the modem control. ! 650: // In PC's this bit is "anded" with the interrupt line. ! 651: // ! 652: // For the Jensen, we will ALWAYS leave the line high. That's ! 653: // the way the hardware engineers want it. ! 654: // ! 655: ! 656: WRITE_MODEM_CONTROL( ! 657: extension->Controller, ! 658: (UCHAR)(READ_MODEM_CONTROL(extension->Controller) | SERIAL_MCR_OUT2) ! 659: ); ! 660: ! 661: extension->DeviceIsOpened = TRUE; ! 662: extension->ErrorWord = 0; ! 663: ! 664: return FALSE; ! 665: ! 666: } ! 667: ! 668: BOOLEAN ! 669: SerialMarkClose( ! 670: IN PVOID Context ! 671: ) ! 672: ! 673: /*++ ! 674: ! 675: Routine Description: ! 676: ! 677: This routine merely sets a boolean to false to mark the fact that ! 678: somebody closed the device and it's no longer worthwhile to pay attention ! 679: to interrupts. ! 680: ! 681: Arguments: ! 682: ! 683: Context - Really a pointer to the device extension. ! 684: ! 685: Return Value: ! 686: ! 687: This routine always returns FALSE. ! 688: ! 689: --*/ ! 690: ! 691: { ! 692: ! 693: PSERIAL_DEVICE_EXTENSION extension = Context; ! 694: ! 695: // ! 696: // Prepare for the closing by stopping interrupts. ! 697: // ! 698: // We do this by adjusting the OUT2 line in the modem control. ! 699: // In PC's this bit is "anded" with the interrupt line. ! 700: // ! 701: // The line should stay high on the Jensen because that's the ! 702: // way the hardware engineers did it. ! 703: // ! 704: ! 705: if (!extension->Jensen) { ! 706: ! 707: WRITE_MODEM_CONTROL( ! 708: extension->Controller, ! 709: (UCHAR)(READ_MODEM_CONTROL(extension->Controller) & ~SERIAL_MCR_OUT2) ! 710: ); ! 711: ! 712: } ! 713: ! 714: if (extension->FifoPresent) { ! 715: ! 716: WRITE_FIFO_CONTROL( ! 717: extension->Controller, ! 718: (UCHAR)0 ! 719: ); ! 720: ! 721: } ! 722: ! 723: extension->DeviceIsOpened = FALSE; ! 724: ! 725: return FALSE; ! 726: ! 727: } ! 728: ! 729: NTSTATUS ! 730: SerialCleanup( ! 731: IN PDEVICE_OBJECT DeviceObject, ! 732: IN PIRP Irp ! 733: ) ! 734: ! 735: /*++ ! 736: ! 737: Routine Description: ! 738: ! 739: This function is used to kill all longstanding IO operations. ! 740: ! 741: Arguments: ! 742: ! 743: DeviceObject - Pointer to the device object for this device ! 744: ! 745: Irp - Pointer to the IRP for the current request ! 746: ! 747: Return Value: ! 748: ! 749: The function value is the final status of the call ! 750: ! 751: --*/ ! 752: ! 753: { ! 754: ! 755: PSERIAL_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension; ! 756: KIRQL oldIrql; ! 757: ! 758: SerialDump( ! 759: SERIRPPATH, ! 760: ("SERIAL: Dispatch entry for: %x\n",Irp) ! 761: ); ! 762: // ! 763: // First kill all the reads and writes. ! 764: // ! 765: ! 766: SerialKillAllReadsOrWrites( ! 767: DeviceObject, ! 768: &extension->WriteQueue, ! 769: &extension->CurrentWriteIrp ! 770: ); ! 771: ! 772: SerialKillAllReadsOrWrites( ! 773: DeviceObject, ! 774: &extension->ReadQueue, ! 775: &extension->CurrentReadIrp ! 776: ); ! 777: ! 778: // ! 779: // Next get rid of purges. ! 780: // ! 781: ! 782: SerialKillAllReadsOrWrites( ! 783: DeviceObject, ! 784: &extension->PurgeQueue, ! 785: &extension->CurrentPurgeIrp ! 786: ); ! 787: ! 788: // ! 789: // Get rid of any mask operations. ! 790: // ! 791: ! 792: SerialKillAllReadsOrWrites( ! 793: DeviceObject, ! 794: &extension->MaskQueue, ! 795: &extension->CurrentMaskIrp ! 796: ); ! 797: ! 798: // ! 799: // Now get rid a pending wait mask irp. ! 800: // ! 801: ! 802: IoAcquireCancelSpinLock(&oldIrql); ! 803: ! 804: if (extension->CurrentWaitIrp) { ! 805: ! 806: PDRIVER_CANCEL cancelRoutine; ! 807: ! 808: cancelRoutine = extension->CurrentWaitIrp->CancelRoutine; ! 809: extension->CurrentWaitIrp->Cancel = TRUE; ! 810: ! 811: if (cancelRoutine) { ! 812: ! 813: extension->CurrentWaitIrp->CancelIrql = oldIrql; ! 814: extension->CurrentWaitIrp->CancelRoutine = NULL; ! 815: ! 816: cancelRoutine( ! 817: DeviceObject, ! 818: extension->CurrentWaitIrp ! 819: ); ! 820: ! 821: } ! 822: ! 823: } else { ! 824: ! 825: IoReleaseCancelSpinLock(oldIrql); ! 826: ! 827: } ! 828: ! 829: Irp->IoStatus.Status = STATUS_SUCCESS; ! 830: Irp->IoStatus.Information=0L; ! 831: ! 832: SerialDump( ! 833: SERIRPPATH, ! 834: ("SERIAL: Complete Irp: %x\n",Irp) ! 835: ); ! 836: IoCompleteRequest( ! 837: Irp, ! 838: IO_NO_INCREMENT ! 839: ); ! 840: ! 841: return STATUS_SUCCESS; ! 842: ! 843: } ! 844: ! 845: LARGE_INTEGER ! 846: SerialGetCharTime( ! 847: IN PSERIAL_DEVICE_EXTENSION Extension ! 848: ) ! 849: ! 850: /*++ ! 851: ! 852: Routine Description: ! 853: ! 854: This function will return the number of 100 nanosecond intervals ! 855: there are in one character time (based on the present form ! 856: of flow control. ! 857: ! 858: Arguments: ! 859: ! 860: Extension - Just what it says. ! 861: ! 862: Return Value: ! 863: ! 864: 100 nanosecond intervals in a character time. ! 865: ! 866: --*/ ! 867: ! 868: { ! 869: ! 870: ULONG dataSize; ! 871: ULONG paritySize; ! 872: ULONG stopSize; ! 873: ULONG charTime; ! 874: ULONG bitTime; ! 875: ! 876: ! 877: if ((Extension->LineControl & SERIAL_DATA_MASK) == SERIAL_5_DATA) { ! 878: dataSize = 5; ! 879: } else if ((Extension->LineControl & SERIAL_DATA_MASK) ! 880: == SERIAL_6_DATA) { ! 881: dataSize = 6; ! 882: } else if ((Extension->LineControl & SERIAL_DATA_MASK) ! 883: == SERIAL_7_DATA) { ! 884: dataSize = 7; ! 885: } else if ((Extension->LineControl & SERIAL_DATA_MASK) ! 886: == SERIAL_8_DATA) { ! 887: dataSize = 8; ! 888: } ! 889: ! 890: paritySize = 1; ! 891: if ((Extension->LineControl & SERIAL_PARITY_MASK) ! 892: == SERIAL_NONE_PARITY) { ! 893: ! 894: paritySize = 0; ! 895: ! 896: } ! 897: ! 898: if (Extension->LineControl & SERIAL_2_STOP) { ! 899: ! 900: // ! 901: // Even if it is 1.5, for sanities sake were going ! 902: // to say 2. ! 903: // ! 904: ! 905: stopSize = 2; ! 906: ! 907: } else { ! 908: ! 909: stopSize = 1; ! 910: ! 911: } ! 912: ! 913: // ! 914: // First we calculate the number of 100 nanosecond intervals ! 915: // are in a single bit time (Approximately). ! 916: // ! 917: ! 918: bitTime = (10000000+(Extension->CurrentBaud-1))/Extension->CurrentBaud; ! 919: charTime = bitTime + ((dataSize+paritySize+stopSize)*bitTime); ! 920: ! 921: return RtlConvertUlongToLargeInteger(charTime); ! 922: ! 923: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.