![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pardrvr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / comm / oldpar|
Return to pardrvr.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / comm / oldpar |
1.1 root 1: /*++
2:
3: Copyright (c) 1990 Microsoft Corporation
4:
5: Module Name:
6:
7: pardrvr.c
8:
9: Abstract:
10:
11: This module contains the code that does the non-initialization work
12: of the parallel driver.
13:
14: Environment:
15:
16: Kernel mode
17:
18: Revision History :
19:
20: The code is set up to be mostly interrupt driven. Some printers
21: won't interrupt when initialized, so the is structured so that
22: when it starts a request, it will determine if a previous initialize
23: was done - and if so did it complete correctly.
24:
25: In addition, code has been adjusted so that an interrupt can't be
26: aquired for port, then we will drive the port using a timer dpc
27: that will attempt to push X characters out while polling the port.
28: If a port isn't ready after Y microseconds then the timer will be
29: resubmitted to try again later.
30:
31: Access to device extension variables
32:
33: The access on these variables may be serialized :
34: TimerCount, Initialized, Initializing, CountBuffer, Command,
35: CompletingIoControl.
36:
37: TimerCount is useful for the management of timeout; when the driver
38: makes an operation on the controller, it sets a timeout, if the interrupt
39: genrated by ACK doesn't arrive the timer routine complete the
40: operation with a failure result.
41: TimerCount is modified by : InitializeDevice, ManageTimeOut,
42: InitiateIo, ISR.
43:
44: Initialized is true when the device is initialized.
45: Initialized is modified by : InitializeDevice, ISR, InitiateIo.
46:
47: Initializing is TRUE when an initialization of the device is going on.
48: Initializing is modified by : InitializeDevice, ISR,
49: ManageTimeOut.
50:
51: CountBuffer is != 0 when a writing is going on, it is the number of
52: characters the driver has still to send to the controller to end the
53: operation.
54: CountBuffer is modified by : Initialize, ManageTimeOut, ISR,
55: StartCriticalFunctions.
56:
57: Command is the command the driver is servicing.
58: Command is modified by : StartCriticalFunctions, ManageIoDevice.
59:
60: CompletingIoControl it is useful to synchronize Dpc and TimerRoutine
61: when IoControl is completing.
62:
63: --*/
64:
65: //
66: // Note that we include ntddser that we can use the serials
67: // timeout structure and ioctl to set the timeout for a write.
68: //
69:
70: #include <stddef.h>
71: #include "ntddk.h"
72: #include "ntddpar.h"
73: #include "ntddser.h"
74: #include "par.h"
75: #include "parlog.h"
76:
77: static const PHYSICAL_ADDRESS ParPhysicalZero = {0};
78:
79: #define PAR_INIT_TIMEOUT_VALUE 2
80:
81: #define VALID_FLAGS PARALLEL_INIT & ( PARALLEL_INIT | PARALLEL_AUTOFEED )
82:
83: typedef enum _PAR_DPC_ACTION {
84: ParCompleteWrite,
85: ParCompleteSetIoctl,
86: ParUnknownError,
87: ParPoweredOff,
88: ParNotConnected,
89: ParOffline,
90: ParPaperEmpty,
91: ParBusy,
92: ParDebug,
93: ParCancel
94: } PAR_DPC_ACTION, *PPAR_ACTION;
95:
96: typedef struct _CONTROL_AREA {
97: PPAR_DEVICE_EXTENSION Extension;
98: UCHAR Status;
99: UCHAR Control;
100: PIRP Irp;
101: } CONTROL_AREA, *PCONTROL_AREA;
102:
103: typedef struct _PAR_SYNCH_COUNT {
104: PPAR_DEVICE_EXTENSION Extension;
105: ULONG OldCount;
106: } PAR_SYNCH_COUNT,*PPAR_SYNCH_COUNT;
107:
108:
109: //
110: // Declarations for all internal and external routines used by this module
111: //
112:
113:
114:
115: //
116: //Macros definitions
117: //
118:
119: //
120: // Busy, PE
121: //
122:
123: #define PAR_PAPER_EMPTY( Status ) ( \
124: (Status & PAR_STATUS_PE) )
125:
126: //
127: // Busy, not select, not error
128: //
129:
130: #define PAR_OFF_LINE( Status ) ( \
131: (Status & PAR_STATUS_NOT_ERROR) && \
132: ((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
133: !(Status & PAR_STATUS_SLCT) )
134:
135: //
136: // error, ack, not busy
137: //
138:
139: #define PAR_POWERED_OFF( Status ) ( \
140: ((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR) && \
141: ((Status & PAR_STATUS_NOT_ACK) ^ PAR_STATUS_NOT_ACK) && \
142: (Status & PAR_STATUS_NOT_BUSY))
143:
144: //
145: // not error, not busy, not select
146: //
147:
148: #define PAR_NOT_CONNECTED( Status ) ( \
149: (Status & PAR_STATUS_NOT_ERROR) && \
150: (Status & PAR_STATUS_NOT_BUSY) &&\
151: !(Status & PAR_STATUS_SLCT) )
152:
153: //
154: // not error, not busy
155: //
156:
157: #define PAR_OK(Status) ( \
158: (Status & PAR_STATUS_NOT_ERROR) && \
159: ((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
160: (Status & PAR_STATUS_NOT_BUSY) )
161:
162: //
163: // not error, not busy, selected.
164: //
165: #define PAR_ONLINE(Status) ( \
166: (Status & PAR_STATUS_NOT_ERROR) && \
167: (Status & PAR_STATUS_NOT_BUSY) && \
168: ((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
169: (Status & PAR_STATUS_SLCT) )
170:
171: //
172: // busy, select, not error
173: //
174:
175: #define PAR_POWERED_ON(Status) ( \
176: ((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
177: (Status & PAR_STATUS_SLCT) && \
178: (Status & PAR_STATUS_NOT_ERROR))
179:
180: //
181: // busy, not error
182: //
183:
184: #define PAR_BUSY(Status) (\
185: (( Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
186: ( Status & PAR_STATUS_NOT_ERROR ) )
187:
188: //
189: // selected
190: //
191:
192: #define PAR_SELECTED(Status) ( \
193: ( Status & PAR_STATUS_SLCT ) )
194:
195: //
196: // No cable attached.
197: //
198: #define PAR_NO_CABLE(Status) ( \
199: ((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
200: (Status & PAR_STATUS_NOT_ACK) && \
201: (Status & PAR_STATUS_PE) && \
202: (Status & PAR_STATUS_SLCT) && \
203: (Status & PAR_STATUS_NOT_ERROR))
204:
205: //
206: // autofeed
207: //
208:
209: #define PAR_AUTOFEED( Control ) (\
210: ( Control & PAR_CONTROL_AUTOFD ) )
211:
212:
213: BOOLEAN
214: ParInitializeDevice(
215: IN PVOID Context
216: )
217:
218: /*++
219:
220: Routine Description:
221:
222: This routine is invoked to initialize the parallel port drive.
223: It performs the following actions:
224:
225: o Sets the timer, because an interrupt is expected on the last
226: StoreControl
227:
228: o Send INIT to the driver and if the device is online, it sends
229: SLIN
230:
231: This routine is invoked by ParInitialize and InterruptServiceRoutine, and
232: its execution is synchronized with ISR execution.
233:
234: Arguments:
235:
236: Context - Really the device extension.
237:
238: Return Value:
239:
240: Always FALSE.
241:
242: --*/
243:
244: {
245:
246: PPAR_DEVICE_EXTENSION extension = Context;
247:
248: ParDump(
249: PARINITDEV,
250: ("PARALLEL: In ParInitializeDevice - device status is %x\n",
251: GetStatus(extension->Controller))
252: );
253:
254: if ((!extension->Initialized) ||
255: ((extension->Command == ParSetInformation) &&
256: !extension->CompletingIoControl)) {
257:
258: UCHAR irqValue = ((extension->UsingATimer)?(0):
259: (PAR_CONTROL_IRQ_ENB));
260:
261: extension->Initializing = TRUE;
262:
263: //
264: // Clear the register.
265: //
266:
267: if (GetControl(extension->Controller) &
268: PAR_CONTROL_NOT_INIT) {
269:
270: StoreControl(
271: extension->Controller,
272: (UCHAR)(PAR_CONTROL_WR_CONTROL | irqValue)
273: );
274: KeStallExecutionProcessor(60);
275:
276: }
277:
278: if (extension->AutoFeed) {
279:
280: StoreControl(
281: extension->Controller,
282: (UCHAR)(PAR_CONTROL_WR_CONTROL | PAR_CONTROL_NOT_INIT |
283: PAR_CONTROL_AUTOFD | irqValue)
284: );
285:
286: } else {
287:
288: StoreControl(
289: extension->Controller,
290: (UCHAR)(PAR_CONTROL_WR_CONTROL | PAR_CONTROL_NOT_INIT |
291: irqValue)
292: );
293:
294: }
295:
296: extension->TimerCount = PAR_INIT_TIMEOUT_VALUE;
297:
298: }
299:
300: return FALSE;
301:
302: }
303:
304: VOID
305: ParTimerRoutine(
306: IN PDEVICE_OBJECT DeviceObject,
307: IN PVOID Context
308: )
309:
310: /*++
311:
312: Routine Description:
313:
314: This is the driver's timer routine. It is invoked once every second.
315: The value of the timeout counter is set in the Interrupt Service Routine
316: (ISR) and decremented by the ParManageTimeOut function, invoked by this
317: routine. If the current operation has timed out, then it is the function
318: of this routine to complete the current packet with an error status and
319: get the next operation started.
320:
321: A timeout may occur under any of the following conditions:
322:
323: o The device is powered off.
324:
325: o The device is disconnected.
326:
327: o The device is off-line.
328:
329: o PE?
330:
331: Arguments:
332:
333: DeviceObject - Pointer to the device object associated with this device.
334:
335: Context - Unused context parameter.
336:
337: Return value:
338:
339: None.
340:
341: --*/
342:
343: {
344:
345: PPAR_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
346:
347: UNREFERENCED_PARAMETER(Context);
348:
349: //
350: // the test isn't in a critical region, because it can loose a round
351: // It is useful to avoid the useless ParSynchronizeExecution call.
352: //
353:
354: if (extension->TimerCount != -1) {
355:
356: KIRQL cancelIrql;
357:
358: ParDump(
359: PARTIMEOUT,
360: ("PARALLEL: In ParTimerRoutine - about to sync with ISR\n")
361: );
362: IoAcquireCancelSpinLock(&cancelIrql);
363: ParSynchronizeExecution(
364: extension,
365: ParManageTimeOut,
366: DeviceObject
367: );
368: IoReleaseCancelSpinLock(cancelIrql);
369:
370:
371: }
372:
373: if (extension->StormKnocksOutInterrupts) {
374:
375: extension->StormKnocksOutInterrupts = FALSE;
376:
377: ParLogError(
378: DeviceObject->DriverObject,
379: DeviceObject,
380: extension->OriginalController,
381: ParPhysicalZero,
382: 0,
383: 0,
384: 0,
385: 41,
386: STATUS_SUCCESS,
387: PAR_INTERRUPT_STORM
388: );
389:
390: }
391:
392: }
393:
394: BOOLEAN
395: ParManageTimeOut(
396: IN PVOID Context
397: )
398:
399: /*++
400:
401: Routine Description:
402:
403: This routine sets the status of the device in the extension when
404: an interrupt was expected didn't arrive and timeout was reached.
405:
406: This function is synchronized with the ISR.
407:
408: Arguments:
409:
410: Context - Really a pointer to the device object.
411:
412: Return value:
413:
414: Always FALSE.
415:
416: --*/
417:
418: {
419:
420: PDEVICE_OBJECT deviceObject = Context;
421: PPAR_DEVICE_EXTENSION extension = deviceObject->DeviceExtension;
422:
423: ParDump(
424: PARTIMEOUT,
425: ("PARALLEL: In ParManageTimeout\n")
426: );
427:
428: //
429: // Reset the storm interrupt count back to zero on each timer tick.
430: //
431:
432: extension->UnexpectedCount = 0;
433:
434: if (extension->TimerCount < 0) {
435:
436: //
437: // Nothing to do.
438: //
439: return FALSE;
440:
441: } else {
442:
443: //
444: // We can assume that we are called with the cancel spinlock
445: // held. Check to see if we have a current irp, and if so
446: // was it canceled.
447: //
448:
449: if (deviceObject->CurrentIrp) {
450:
451: if (deviceObject->CurrentIrp->Cancel) {
452:
453: ParDump(
454: PARTIMEOUT,
455: ("PARALLEL: In ParManageTimeout - irp %x has been cancelled\n",
456: deviceObject->CurrentIrp)
457: );
458: extension->TimerCount = -1;
459: IoRequestDpc(
460: deviceObject,
461: deviceObject->CurrentIrp,
462: (PVOID)ParCancel
463: );
464: return FALSE;
465:
466: }
467:
468: }
469:
470: if (extension->TimerCount > 0) {
471:
472: //
473: // We are going to call the isr routine. We do this
474: // so that if the device went on/off line during IO
475: // we can start up the IO again. The driver will NOT
476: // put a character out to the device if it is off line.
477: //
478:
479: ParInterruptServiceRoutine(
480: extension->Interrupt,
481: extension->DeviceObject
482: );
483: if (extension->TimerCount != -1) {
484:
485: ASSERT(extension->TimerCount);
486: extension->TimerCount--;
487:
488: }
489: return FALSE;
490:
491: } else {
492:
493: UCHAR deviceStatus = GetStatus(extension->Controller);
494: PAR_DPC_ACTION action;
495:
496: extension->TimerCount = -1;
497:
498: ParDump(
499: PARTIMEOUT,
500: ("PARALLEL: In timeout status of device is %x\n",
501: deviceStatus)
502: );
503:
504: //
505: // CountBuffer is = 0 if no packet is being writtten or a Dpc
506: // is completing a request
507: //
508:
509: if (extension->Initializing) {
510:
511: extension->Initializing = FALSE;
512:
513: //
514: // This is a patch for the Centronic Interface for the
515: // laser printer that hasn't INIT pin, so it doesn't
516: // generate an interrupt when it is initialized.
517: //
518:
519: if (PAR_OK(deviceStatus)) {
520:
521: ParDump(
522: PARTIMEOUT,
523: ("PARALLEL - ParManageTimeout: In centronics patch\n")
524: );
525: extension->Initialized = TRUE;
526:
527: if ((extension->Command == ParSetInformation) &&
528: !extension->CompletingIoControl ) {
529:
530: extension->CompletingIoControl = TRUE;
531: IoRequestDpc(
532: deviceObject,
533: deviceObject->CurrentIrp,
534: (PVOID)ParCompleteSetIoctl
535: );
536:
537: }
538:
539: return FALSE;
540:
541: }
542:
543: }
544:
545: if ((extension->CountBuffer != 0) ||
546: ((extension->Command == ParSetInformation ) &&
547: !extension->CompletingIoControl)) {
548:
549: extension->CompletingIoControl = TRUE;
550:
551: if (PAR_POWERED_OFF(deviceStatus) ||
552: PAR_NO_CABLE(deviceStatus)) {
553:
554: ParDump(
555: PARTIMEOUT,
556: ("PARALLEL - ParManageTimeout: powered off\n")
557: );
558: extension->Initialized = FALSE;
559: action = ParPoweredOff;
560:
561: } else if (PAR_NOT_CONNECTED(deviceStatus)) {
562:
563: ParDump(
564: PARTIMEOUT,
565: ("PARALLEL - ParManageTimeout: not connected\n")
566: );
567: extension->Initialized = FALSE;
568: action = ParNotConnected;
569:
570: } else if (PAR_OFF_LINE(deviceStatus)) {
571:
572: ParDump(
573: PARTIMEOUT,
574: ("PARALLEL - ParManageTimeout: off line\n")
575: );
576: action = ParOffline;
577:
578: } else if (PAR_PAPER_EMPTY(deviceStatus)) {
579:
580: ParDump(
581: PARTIMEOUT,
582: ("PARALLEL - ParManageTimeout: paper empty\n")
583: );
584: action = ParPaperEmpty;
585:
586: } else if (PAR_BUSY(deviceStatus)) {
587:
588: ParDump(
589: PARTIMEOUT,
590: ("PARALLEL - ParManageTimeout: busy\n")
591: );
592: action = ParBusy;
593:
594: } else {
595:
596: //
597: // This code should never be executed.
598: //
599:
600: ParDump(
601: PARTIMEOUT,
602: ("PARALLEL - ParManageTimeout: shouldn't be here\n")
603: );
604: extension->Initialized = FALSE;
605: action = ParUnknownError;
606:
607: }
608:
609: IoRequestDpc(
610: deviceObject,
611: deviceObject->CurrentIrp,
612: (PVOID)action
613: );
614:
615: }
616:
617: }
618:
619: }
620:
621: return FALSE;
622: }
623:
624: BOOLEAN
625: ParSetTimerStart(
626: IN PVOID Context
627: )
628:
629: /*++
630:
631: Routine Description:
632:
633: This routine is invoked via KeSynchronize. It is used to
634: set the value that we should start counting down with
635: after every successful IO operation.
636:
637: Arguments:
638:
639: Context - Really a pointer to the irp.
640:
641: Return Value:
642:
643: Always False.
644:
645: --*/
646:
647: {
648:
649: PPAR_DEVICE_EXTENSION extension =
650: IoGetCurrentIrpStackLocation((PIRP)Context)
651: ->DeviceObject->DeviceExtension;
652:
653: PSERIAL_TIMEOUTS New =
654: ((PSERIAL_TIMEOUTS)(((PIRP)Context)->AssociatedIrp.SystemBuffer));
655:
656: ParDump(
657: PARDISPATCH,
658: ("Parallel: SET TIME OUT to %d seconds\n",
659: extension->TimerStart)
660: );
661: extension->TimerStart = New->WriteTotalTimeoutConstant / 1000;
662:
663: return FALSE;
664: }
665:
666: NTSTATUS
667: ParDispatch(
668: IN PDEVICE_OBJECT DeviceObject,
669: IN PIRP Irp
670: )
671:
672: /*++
673:
674: Routine Description:
675:
676: This is the main dispatch routine for the parallel port driver.
677: It is given a pointer to the IRP for the current request and
678: it determines what to do with it. If the request is valid and doen't
679: have any parameter errors, then it is placed into the work queue.
680: Otherwise it is not completed and an appropriate error is returned.
681:
682: Arguments:
683:
684: DeviceObject - Pointer to the device object for this device
685:
686: Irp - Pointer to the IRP for the current request
687:
688: Return Value:
689:
690: The function value is the final status of the call
691:
692: --*/
693:
694: {
695:
696: NTSTATUS status = STATUS_SUCCESS;
697: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
698: PPAR_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
699:
700: ParDump(
701: PARDISPATCH,
702: ("PARALLEL: In main dispatch with IRP: %x\n",
703: Irp)
704: );
705: Irp->IoStatus.Information=0L;
706: switch(irpSp->MajorFunction) {
707:
708: case IRP_MJ_CLOSE: {
709:
710: ParDump(
711: PARDISPATCH,
712: ("PARALLEL: About to close the port for extension: %x\n",
713: extension)
714: );
715: //
716: // Before we close we want to wait until the busy
717: // path is false. We don't want any paths of
718: // execution running around while we're closed.
719: //
720:
721: while (extension->BusyPath) {
722:
723: KeDelayExecutionThread(
724: KernelMode,
725: FALSE,
726: &extension->BusyDelayAmount
727: );
728:
729: }
730: break;
731:
732:
733: }
734: case IRP_MJ_CREATE:
735:
736: ParDump(
737: PARDISPATCH,
738: ("PARALLEL: About to open the port for extension: %x\n",
739: extension)
740: );
741: //
742: // Let's make sure they aren't trying to create a directory.
743: // This is a silly, but what's a driver to do!?
744: //
745:
746: if (irpSp->Parameters.Create.Options & FILE_DIRECTORY_FILE) {
747:
748: status = STATUS_NOT_A_DIRECTORY;
749:
750: }
751:
752: break;
753:
754: case IRP_MJ_WRITE:
755:
756: ParDump(
757: PARDISPATCH,
758: ("PARALLEL: Starting write IRP: %x for extension: %x\n",
759: Irp,
760: extension)
761: );
762: if ((irpSp->Parameters.Write.ByteOffset.HighPart != 0) ||
763: (irpSp->Parameters.Write.ByteOffset.LowPart != 0)) {
764:
765: status = STATUS_INVALID_PARAMETER;
766:
767: } else {
768:
769: if (irpSp->Parameters.Write.Length != 0) {
770:
771: status = STATUS_PENDING;
772: }
773:
774: }
775:
776: break;
777:
778: case IRP_MJ_DEVICE_CONTROL:
779:
780: ParDump(
781: PARDISPATCH,
782: ("PARALLEL: Starting device controlIRP: %x for extension: %x\n",
783: Irp,
784: extension)
785: );
786: switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {
787:
788: case IOCTL_PAR_SET_INFORMATION :
789:
790: if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
791: 1) {
792:
793: status = STATUS_BUFFER_TOO_SMALL;
794:
795: } else {
796:
797: PPAR_SET_INFORMATION irpBuffer =
798: Irp->AssociatedIrp.SystemBuffer;
799:
800: //
801: // INIT is required, AUTOFEED is optional
802: //
803:
804: if (!(irpBuffer->Init & PARALLEL_INIT) ||
805: (irpBuffer->Init & ~VALID_FLAGS)) {
806:
807: status = STATUS_INVALID_PARAMETER;
808:
809: } else {
810:
811: status = STATUS_PENDING;
812: }
813:
814: }
815:
816: break;
817:
818: case IOCTL_PAR_QUERY_INFORMATION :
819:
820: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
821: sizeof(PAR_QUERY_INFORMATION)) {
822:
823: status = STATUS_BUFFER_TOO_SMALL;
824:
825: } else {
826:
827: status = STATUS_PENDING;
828: }
829:
830: break;
831:
832: case IOCTL_SERIAL_SET_TIMEOUTS: {
833:
834: PSERIAL_TIMEOUTS NewTimeouts =
835: ((PSERIAL_TIMEOUTS)(Irp->AssociatedIrp.SystemBuffer));
836:
837: ParDump(
838: PARDISPATCH,
839: ("PARALLEL: Got a set timeouts irp: %x for extension: %x\n",
840: Irp,
841: extension)
842: );
843:
844: if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
845: sizeof(SERIAL_TIMEOUTS)) {
846:
847: status = STATUS_BUFFER_TOO_SMALL;
848: break;
849:
850: } else if (NewTimeouts->WriteTotalTimeoutConstant < 2000) {
851:
852: status = STATUS_INVALID_PARAMETER;
853: break;
854:
855: }
856:
857: ParSynchronizeExecution(
858: extension,
859: ParSetTimerStart,
860: Irp
861: );
862:
863: break;
864:
865: }
866: case IOCTL_SERIAL_GET_TIMEOUTS:
867:
868: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
869: sizeof(SERIAL_TIMEOUTS)) {
870:
871: status = STATUS_BUFFER_TOO_SMALL;
872: break;
873:
874: }
875:
876: //
877: // We don't need to synchronize the read.
878: //
879:
880: RtlZeroMemory(
881: Irp->AssociatedIrp.SystemBuffer,
882: sizeof(SERIAL_TIMEOUTS)
883: );
884: Irp->IoStatus.Information = sizeof(SERIAL_TIMEOUTS);
885: ((PSERIAL_TIMEOUTS)Irp->AssociatedIrp.SystemBuffer)->
886: WriteTotalTimeoutConstant =
887: extension->TimerStart * 1000;
888:
889: break;
890:
891: default :
892:
893: status = STATUS_INVALID_PARAMETER;
894: break;
895:
896: }
897:
898: break;
899:
900: }
901:
902: Irp->IoStatus.Status = status;
903:
904: if (status == STATUS_PENDING) {
905:
906: IoMarkIrpPending(Irp);
907: IoStartPacket(
908: DeviceObject,
909: Irp,
910: (PULONG)NULL,
911: ParCancelRequest
912: );
913:
914: } else {
915:
916: ParDump(
917: PARIRPCOMPLETE,
918: ("PARALLEL: About to complete IRP in dispatch: %x\n",Irp)
919: );
920: IoCompleteRequest(
921: Irp,
922: IO_NO_INCREMENT
923: );
924:
925: }
926:
927: return status;
928:
929: }
930:
931: NTSTATUS
932: ParQueryInformationFile(
933: IN PDEVICE_OBJECT DeviceObject,
934: IN PIRP Irp
935: )
936:
937: /*++
938:
939: Routine Description:
940:
941: This routine is used to query the end of file information on
942: the opened parallel port. Any other file information request
943: is retured with an invalid parameter.
944:
945: This routine always returns an end of file of 0.
946:
947: Arguments:
948:
949: DeviceObject - Pointer to the device object for this device
950:
951: Irp - Pointer to the IRP for the current request
952:
953: Return Value:
954:
955: The function value is the final status of the call
956:
957: --*/
958:
959: {
960: //
961: // The status that gets returned to the caller and
962: // set in the Irp.
963: //
964: NTSTATUS status = STATUS_SUCCESS;
965:
966: //
967: // The current stack location. This contains all of the
968: // information we need to process this particular request.
969: //
970: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
971:
972: UNREFERENCED_PARAMETER(DeviceObject);
973:
974: ParDump(
975: PARDISPATCH,
976: ("PARALLEL: In query information file with Irp: %x\n",
977: Irp)
978: );
979: Irp->IoStatus.Information = 0L;
980: if (irpSp->Parameters.QueryFile.FileInformationClass ==
981: FileStandardInformation) {
982:
983: PFILE_STANDARD_INFORMATION buf = Irp->AssociatedIrp.SystemBuffer;
984:
985: buf->AllocationSize = RtlConvertUlongToLargeInteger(0ul);
986: buf->EndOfFile = buf->AllocationSize;
987: buf->NumberOfLinks = 0;
988: buf->DeletePending = FALSE;
989: buf->Directory = FALSE;
990: Irp->IoStatus.Information = sizeof(FILE_STANDARD_INFORMATION);
991:
992: } else if (irpSp->Parameters.QueryFile.FileInformationClass ==
993: FilePositionInformation) {
994:
995: ((PFILE_POSITION_INFORMATION)Irp->AssociatedIrp.SystemBuffer)->
996: CurrentByteOffset = RtlConvertUlongToLargeInteger(0ul);
997: Irp->IoStatus.Information = sizeof(FILE_POSITION_INFORMATION);
998:
999: } else {
1000:
1001: status = STATUS_INVALID_PARAMETER;
1002:
1003: }
1004:
1005: Irp->IoStatus.Status = status;
1006: ParDump(
1007: PARIRPCOMPLETE,
1008: ("PARALLEL: About to complete IRP: %x\n",Irp)
1009: );
1010: IoCompleteRequest(
1011: Irp,
1012: IO_NO_INCREMENT
1013: );
1014:
1015: return status;
1016:
1017: }
1018:
1019: NTSTATUS
1020: ParSetInformationFile(
1021: IN PDEVICE_OBJECT DeviceObject,
1022: IN PIRP Irp
1023: )
1024:
1025: /*++
1026:
1027: Routine Description:
1028:
1029: This routine is used to set the end of file information on
1030: the opened parallel port. Any other file information request
1031: is retured with an invalid parameter.
1032:
1033: This routine always ignores the actual end of file since
1034: the query information code always returns an end of file of 0.
1035:
1036: Arguments:
1037:
1038: DeviceObject - Pointer to the device object for this device
1039:
1040: Irp - Pointer to the IRP for the current request
1041:
1042: Return Value:
1043:
1044: The function value is the final status of the call
1045:
1046: --*/
1047:
1048: {
1049:
1050: NTSTATUS status = STATUS_SUCCESS;
1051:
1052: UNREFERENCED_PARAMETER(DeviceObject);
1053:
1054: ParDump(
1055: PARDISPATCH,
1056: ("PARALLEL: In set information with IRP: %x\n",
1057: Irp)
1058: );
1059: Irp->IoStatus.Information = 0L;
1060: if (IoGetCurrentIrpStackLocation(Irp)->
1061: Parameters.SetFile.FileInformationClass !=
1062: FileEndOfFileInformation) {
1063:
1064: status = STATUS_INVALID_PARAMETER;
1065:
1066: }
1067:
1068: Irp->IoStatus.Status = status;
1069: ParDump(
1070: PARIRPCOMPLETE,
1071: ("PARALLEL: About to complete IRP: %x\n",Irp)
1072: );
1073: IoCompleteRequest(
1074: Irp,
1075: IO_NO_INCREMENT
1076: );
1077:
1078: return status;
1079:
1080: }
1081:
1082: VOID
1083: ParCheckTheWeather(
1084: IN PPAR_DEVICE_EXTENSION Extension
1085: )
1086:
1087: /*++
1088:
1089: Routine Description:
1090:
1091: This routine checks to see if we've gotten too many interrupts
1092: within a certain amount of time. If so we turn the device into
1093: a polling device. This is to deal with interrupt storms.
1094:
1095: Arguments:
1096:
1097: Extension - Pointer to the device extension.
1098:
1099: Return Value:
1100:
1101: None.
1102:
1103: --*/
1104:
1105: {
1106:
1107: //
1108: // We've sometimes seen interrupt storms. If had no work to do
1109: // and we are on an EISA or an ISA bus and we've exceeded the
1110: // threshold for interrupts that weren't ours, then turn off
1111: // interrupts, turn on the using a timer flag, and set a variable
1112: // that our one second timer routine will note to cause it to
1113: // put an event in the event log that this occured.
1114:
1115: if ((Extension->UnexpectedCount > PARALLEL_STORM_WATCH) &&
1116: (!Extension->UsingATimer) &&
1117: ((Extension->InterfaceType == Eisa) ||
1118: (Extension->InterfaceType == Isa))) {
1119:
1120: if (Extension->AutoFeed) {
1121:
1122: StoreControl(
1123: Extension->Controller,
1124: (UCHAR)(PAR_CONTROL_WR_CONTROL | PAR_CONTROL_NOT_INIT |
1125: PAR_CONTROL_AUTOFD)
1126: );
1127:
1128: } else {
1129:
1130: StoreControl(
1131: Extension->Controller,
1132: (UCHAR)(PAR_CONTROL_WR_CONTROL | PAR_CONTROL_NOT_INIT)
1133: );
1134:
1135: }
1136:
1137: Extension->StormKnocksOutInterrupts = TRUE;
1138: Extension->UsingATimer = TRUE;
1139:
1140: }
1141:
1142: }
1143:
1144: BOOLEAN
1145: ParInterruptServiceRoutine(
1146: IN PKINTERRUPT InterruptObject,
1147: IN PVOID Context
1148: )
1149:
1150: /*++
1151:
1152: Routine Description:
1153:
1154: This is the interrupt service routine for the parallel port driver.
1155: An interrupt will occur under any of the following conditions:
1156:
1157: o A character was received by the device
1158:
1159: o The device's power was switched off
1160:
1161: o In some printers PAPER_EMPTY and OFF_LINE don't generate
1162: interrupts, but they are read on the status when a character
1163: is received ( because the printer accepts one more character )
1164:
1165: Arguments:
1166:
1167: InterruptObject - Pointer to the interrupt object used to connect
1168: to the interrupt vector for the parallel port
1169:
1170: Context - Really a Pointer to the device object for the parallel
1171: port device that is interrupting
1172:
1173: Return Value:
1174:
1175: Returns TRUE if an interrupt was expected from the device;
1176: otherwise FALSE
1177:
1178: --*/
1179:
1180: {
1181:
1182: LONG saveTimer;
1183: PDEVICE_OBJECT deviceObject = Context;
1184: PPAR_DEVICE_EXTENSION extension = deviceObject->DeviceExtension;
1185: UCHAR deviceStatus;
1186: PAR_DPC_ACTION action;
1187:
1188: UNREFERENCED_PARAMETER(InterruptObject);
1189:
1190: deviceStatus = GetStatus(extension->Controller);
1191:
1192: ParDump(
1193: PARISR,
1194: ("PARALLEL: ISR - device status is %x\n",deviceStatus)
1195: );
1196: //
1197: // saveTimer == -1 implies that there is no current operation
1198: // in progress.
1199: //
1200:
1201: saveTimer = extension->TimerCount;
1202: action = ParUnknownError;
1203: extension->TimerCount = -1;
1204:
1205: if (extension->Initializing) {
1206:
1207: ParDump(
1208: PARISR,
1209: ("PARALLEL: ISR - In initializing code path\n")
1210: );
1211: extension->Initializing = FALSE;
1212:
1213: if (PAR_OK(deviceStatus)) {
1214:
1215: extension->Initialized = TRUE;
1216: if ((extension->Command == ParSetInformation) &&
1217: !extension->CompletingIoControl) {
1218:
1219: ParDump(
1220: PARISR,
1221: ("PARALLEL: ISR - Completing IO control\n")
1222: );
1223: extension->CompletingIoControl = TRUE;
1224: IoRequestDpc(
1225: deviceObject,
1226: deviceObject->CurrentIrp,
1227: (PVOID)ParCompleteWrite
1228: );
1229:
1230: } else if ((extension->CountBuffer != 0) &&
1231: (saveTimer != -1)) {
1232:
1233: ParDump(
1234: PARISR,
1235: ("PARALLEL: ISR Doing More writes - count:%d\n",
1236: extension->CountBuffer)
1237: );
1238: ParInitiateIo(deviceObject);
1239:
1240: }
1241:
1242: return TRUE;
1243:
1244: } else if ((extension->CountBuffer != 0 ) ||
1245: (extension->Command == ParSetInformation) &&
1246: !extension->CompletingIoControl) {
1247:
1248: if (PAR_POWERED_OFF(deviceStatus)) {
1249:
1250: //
1251: // For the real powered off case make sure we aren't
1252: // getting an interrupt storm from turning an HPxp
1253: // off on an MIO-X00 adapter.
1254: //
1255: // If it is just an simple turning off then bumping
1256: // the unexpected count up won't hurt.
1257: //
1258:
1259: extension->UnexpectedCount++;
1260: action = ParPoweredOff;
1261: ParCheckTheWeather(extension);
1262:
1263: } else if (PAR_NO_CABLE(deviceStatus)) {
1264:
1265: action = ParPoweredOff;
1266:
1267: } else if (PAR_OFF_LINE(deviceStatus) ||
1268: PAR_PAPER_EMPTY(deviceStatus)) {
1269:
1270: //
1271: // Paper empty or device off line should let
1272: // the normal time out code handle the problem
1273: //
1274:
1275: extension->TimerCount = saveTimer;
1276: return TRUE;
1277:
1278: } else if (PAR_PAPER_EMPTY(deviceStatus)) {
1279:
1280: action = ParPaperEmpty;
1281:
1282: } else if (PAR_NOT_CONNECTED(deviceStatus)) {
1283:
1284: action = ParNotConnected;
1285:
1286: } else if (PAR_BUSY(deviceStatus)) {
1287:
1288: //
1289: // For the busy state we will just let the regular timeout code
1290: // handle it.
1291: //
1292: extension->TimerCount = saveTimer;
1293: return TRUE;
1294:
1295: }
1296:
1297: ParDump(
1298: PARISR | PARISRACTION,
1299: ("PARALLEL: ISR Completing request with bad status - ACTION: %d\n",
1300: action)
1301: );
1302: IoRequestDpc(
1303: deviceObject,
1304: deviceObject->CurrentIrp,
1305: (PVOID)action
1306: );
1307:
1308: return TRUE;
1309:
1310: }
1311:
1312: } else {
1313:
1314: //
1315: // The port is not being initialized at this point. Check to see
1316: // whether or not it has been initialized at all and drive the
1317: // remainder of the ISR based on the result.
1318: //
1319:
1320: if (extension->Initialized) {
1321:
1322: ParDump(
1323: PARISR,
1324: ("PARALLEL - ISR Inited path\n")
1325: );
1326:
1327:
1328: if (PAR_OK(deviceStatus) && PAR_ONLINE(deviceStatus) &&
1329: (saveTimer != -1)) {
1330:
1331: if (extension->CountBuffer > 0) {
1332:
1333: ParDump(
1334: PARISR,
1335: ("PARALLEL - ISR Inited - more io - count:%d\n",
1336: extension->CountBuffer)
1337: );
1338: ParInitiateIo(deviceObject);
1339:
1340: } else {
1341:
1342: ParDump(
1343: PARISR,
1344: ("PARALLEL - ISR Inited - good io all done:\n")
1345: );
1346: IoRequestDpc(
1347: deviceObject,
1348: deviceObject->CurrentIrp,
1349: (PVOID)ParCompleteWrite
1350: );
1351:
1352: }
1353:
1354: return TRUE;
1355:
1356: } else if ((PAR_OK(deviceStatus)) && (saveTimer != -1) &&
1357: (extension->CountBuffer == 0)) {
1358:
1359: //
1360: // The odd case of the device going off line just after
1361: // we give the hardware the very last byte.
1362: //
1363:
1364: ParDump(
1365: PARISR,
1366: ("PARALLEL - ISR Inited - good io all done:\n")
1367: );
1368: IoRequestDpc(
1369: deviceObject,
1370: deviceObject->CurrentIrp,
1371: (PVOID)ParCompleteWrite
1372: );
1373:
1374: return TRUE;
1375:
1376: } else {
1377:
1378: if ((saveTimer != -1) &&
1379: (PAR_PAPER_EMPTY(deviceStatus) ||
1380: PAR_OFF_LINE(deviceStatus))) {
1381:
1382: //
1383: // Paper empty or device off line should let
1384: // the normal time out code handle the problem
1385: //
1386:
1387: ParDump(
1388: PARISRACTION,
1389: ("PARALLEL: Isr found device to be off line or empty\n")
1390: );
1391: extension->TimerCount = saveTimer;
1392: return TRUE;
1393:
1394: } else if (PAR_POWERED_OFF(deviceStatus) ||
1395: PAR_NOT_CONNECTED(deviceStatus) ||
1396: PAR_NO_CABLE(deviceStatus)) {
1397:
1398: extension->Initialized = FALSE;
1399:
1400: if (saveTimer != -1) {
1401:
1402: if (PAR_POWERED_OFF(deviceStatus)) {
1403:
1404: //
1405: // For the real powered off case make sure we aren't
1406: // getting an interrupt storm from turning an HPxp
1407: // off on an MIO-X00 adapter.
1408: //
1409: // If it is just an simple turning off then bumping
1410: // the unexpected count up won't hurt.
1411: //
1412:
1413: extension->UnexpectedCount++;
1414: action = ParPoweredOff;
1415: ParCheckTheWeather(extension);
1416:
1417: } else if (PAR_NO_CABLE(deviceStatus)) {
1418:
1419: action = ParPoweredOff;
1420:
1421: }
1422:
1423: if (PAR_NOT_CONNECTED(deviceStatus)) {
1424:
1425: action = ParNotConnected;
1426:
1427: }
1428:
1429: ParDump(
1430: PARISR,
1431: ("PARALLEL - ISR Inited off/connected complete "
1432: "irp - action %d\n",action)
1433: );
1434: IoRequestDpc(
1435: deviceObject,
1436: deviceObject->CurrentIrp,
1437: (PVOID)action
1438: );
1439:
1440: return TRUE;
1441:
1442: } else {
1443:
1444: //
1445: // Well we weren't doing an operation, but
1446: // the device has changed state since we
1447: // last looked. So this interrupt might
1448: // as well have been for us.
1449: //
1450:
1451: return TRUE;
1452:
1453: }
1454:
1455: } else if ((PAR_BUSY(deviceStatus)) &&
1456: (saveTimer != -1)) {
1457:
1458: ParDump(
1459: PARISR | PARBUSYPATH,
1460: ("PARALLEL - ISR inited - busy interrupt?\n")
1461: );
1462:
1463: //
1464: // Well we think that we have work to do, but for
1465: // some reason we got an interrupt, yet the device
1466: // thinks it's busy.
1467: //
1468: // Three things could have happened.
1469: //
1470: // 1) We are running this device off a timer
1471: // (NO interrupts are ever being used).
1472: // The driver is just calling the ISR to
1473: // force the work to be done.
1474: //
1475: // 2) We are on some kind of Jazz machine. We
1476: // *THINK* that the part on the machine is
1477: // signaling an interrupt on just the device
1478: // going BUSY, which is bizarre.
1479: //
1480: // 3) Some printers (whose name shall go unmentioned
1481: // except that their initials are HP),
1482: // seem to give an interrupt to acknowledge
1483: // the character, *THEN* decide that they want
1484: // to go busy (I think this is bizarre too).
1485: //
1486: //
1487: // For 1 we could just return, since the run off
1488: // the timer code will calm down and try to run later
1489: // if it gets too many "busys".
1490: //
1491: // For 2 we could also just return, because we
1492: // get another acknowledge interrupt later.
1493: //
1494: // 3 is quite painful because WE ARE NOT GOING
1495: // TO GET ANOTHER INTERRUPT FROM THE DEVICE.
1496: //
1497: // What we do to solve 3 is to queue off a dpc
1498: // that will start a timer that when the timer
1499: // fires will cause a dpc to synchrnoize with the
1500: // isr and then call this isr. If the busy bit
1501: // has gone away then we will just act as if we
1502: // got interrupted. If the busy bit hasn't gone
1503: // away, we just start off the dpc again.
1504: //
1505:
1506: extension->TimerCount = saveTimer;
1507:
1508: //
1509: // If this driver is using a timer to drive the
1510: // writes then we should return that we haven't
1511: // done anything yet with the io.
1512: //
1513:
1514: if (extension->UsingATimer) {
1515:
1516: return FALSE;
1517:
1518: } else {
1519:
1520: if (!extension->BusyPath) {
1521:
1522: extension->BusyPath = TRUE;
1523:
1524: ParDump(
1525: PARBUSYPATH,
1526: ("Parallel: About to queue the start busy"
1527: "timer\n")
1528: );
1529: KeInsertQueueDpc(
1530: &extension->StartBusyTimerDpc,
1531: NULL,
1532: NULL
1533: );
1534:
1535: }
1536:
1537: }
1538:
1539: }
1540:
1541: }
1542:
1543: extension->TimerCount = saveTimer;
1544: return TRUE;
1545:
1546: } else {
1547:
1548: // not initialized
1549:
1550: if (PAR_POWERED_ON(deviceStatus)) {
1551:
1552: ParDump(
1553: PARISR | PARBUSYPATH,
1554: ("PARALLEL: ISR - not initialized / not on\n")
1555: );
1556: extension->AutoFeed = FALSE;
1557: ParInitializeDevice(extension);
1558: return TRUE;
1559:
1560: }
1561:
1562: }
1563:
1564: }
1565:
1566: //
1567: // Well we couldn't find anything to do. Restore the
1568: // timer value and return FALSE.
1569: //
1570:
1571: ParDump(
1572: PARISR,
1573: ("PARALLEL: ISR returning FALSE with a timer count of %d\n",
1574: extension->TimerCount)
1575: );
1576: extension->TimerCount = saveTimer;
1577: extension->UnexpectedCount++;
1578:
1579: ParCheckTheWeather(extension);
1580: return FALSE;
1581:
1582: }
1583:
1584: BOOLEAN
1585: ParSynchCount(
1586: IN PVOID Context
1587: )
1588:
1589: /*++
1590:
1591: Routine Description:
1592:
1593: This routine is synchronized to work at device level (e.g. the
1594: ISR can't be running). It is used to clear the count buffer.
1595: We do this so that when we completing a request prematurely, we
1596: don't have to refer to a variable that the ISR used to determine
1597: if it is doing work. We clear that variable here.
1598:
1599: Arguments:
1600:
1601: Context - Pointer to a struct that contains the extension and.
1602: a ulong to hold the old count.
1603:
1604: Return Value:
1605:
1606: Always False.
1607:
1608: --*/
1609:
1610: {
1611:
1612: PPAR_SYNCH_COUNT synchCount = Context;
1613:
1614: synchCount->OldCount = synchCount->Extension->CountBuffer;
1615: synchCount->Extension->CountBuffer = 0;
1616:
1617: return FALSE;
1618:
1619: }
1620:
1621: VOID
1622: ParDpcRoutine(
1623: IN PKDPC Dpc,
1624: IN PDEVICE_OBJECT DeviceObject,
1625: IN PIRP Irp,
1626: IN PVOID DeferredContext
1627: )
1628:
1629: /*++
1630:
1631: Routine Description:
1632:
1633: This is the DPC routine that complete driver's write operation.
1634:
1635: Arguments:
1636:
1637: DeviceObject - Pointer to the device object
1638:
1639: Irp - Pointer to the current Irp
1640:
1641: DeferredContext - Type of action
1642:
1643: Return Value:
1644:
1645: None.
1646:
1647: --*/
1648:
1649: {
1650:
1651: UNREFERENCED_PARAMETER(Dpc);
1652:
1653: ParDump(
1654: PARDPC,
1655: ("PARALLEL: In ParDpcRoutine - current irp is: %x\n",
1656: Irp)
1657: );
1658:
1659: if (Irp) {
1660:
1661: PPAR_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
1662: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
1663: PAR_DPC_ACTION action = (PAR_DPC_ACTION)DeferredContext;
1664: PAR_SYNCH_COUNT synchCount;
1665: KIRQL cancelIrql;
1666:
1667:
1668: //
1669: // No matter what, this irp is being completed.
1670: // Kill the cancel routine.
1671: //
1672:
1673: IoAcquireCancelSpinLock(&cancelIrql);
1674: Irp->CancelRoutine = NULL;
1675: IoReleaseCancelSpinLock(cancelIrql);
1676:
1677: synchCount.Extension = extension;
1678: synchCount.OldCount = 0;
1679: ParSynchronizeExecution(
1680: extension,
1681: ParSynchCount,
1682: &synchCount
1683: );
1684:
1685: switch (action) {
1686:
1687: case ParCompleteWrite :
1688:
1689: Irp->IoStatus.Status = STATUS_SUCCESS;
1690: Irp->IoStatus.Information = irpSp->Parameters.Write.Length -
1691: synchCount.OldCount;
1692: ParDump(
1693: PARDPC,
1694: ("PARALLEL: DPC - Complete Write\n"
1695: "-------- STATUS/INFORMATON: %x/%x\n",
1696: Irp->IoStatus.Status,
1697: Irp->IoStatus.Information)
1698: );
1699: break;
1700:
1701: case ParCompleteSetIoctl :
1702:
1703: Irp->IoStatus.Status = STATUS_SUCCESS;
1704: ParDump(
1705: PARDPC,
1706: ("PARALLEL: DPC - Complete Set Ioctl\n"
1707: "-------- STATUS/INFORMATON: %x/%x\n",
1708: Irp->IoStatus.Status,
1709: Irp->IoStatus.Information)
1710: );
1711: break;
1712:
1713: case ParPoweredOff :
1714:
1715: Irp->IoStatus.Status = STATUS_DEVICE_POWERED_OFF;
1716: ParDump(
1717: PARDPC,
1718: ("PARALLEL: DPC - powered off\n"
1719: "-------- STATUS/INFORMATON: %x/%x\n",
1720: Irp->IoStatus.Status,
1721: Irp->IoStatus.Information)
1722: );
1723: break;
1724:
1725: case ParNotConnected :
1726:
1727: Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED;
1728: ParDump(
1729: PARDPC,
1730: ("PARALLEL: DPC - not connected\n"
1731: "-------- STATUS/INFORMATON: %x/%x\n",
1732: Irp->IoStatus.Status,
1733: Irp->IoStatus.Information)
1734: );
1735: break;
1736:
1737: case ParOffline :
1738:
1739: Irp->IoStatus.Status = STATUS_DEVICE_OFF_LINE;
1740: Irp->IoStatus.Information = irpSp->Parameters.Write.Length -
1741: synchCount.OldCount;
1742: ParDump(
1743: PARDPC,
1744: ("PARALLEL: DPC - off line\n"
1745: "-------- STATUS/INFORMATON: %x/%x\n",
1746: Irp->IoStatus.Status,
1747: Irp->IoStatus.Information)
1748: );
1749: break;
1750:
1751: case ParPaperEmpty :
1752:
1753: Irp->IoStatus.Status = STATUS_DEVICE_PAPER_EMPTY;
1754: Irp->IoStatus.Information = irpSp->Parameters.Write.Length -
1755: synchCount.OldCount;
1756: ParDump(
1757: PARDPC,
1758: ("PARALLEL: DPC - paper empty\n"
1759: "-------- STATUS/INFORMATON: %x/%x\n",
1760: Irp->IoStatus.Status,
1761: Irp->IoStatus.Information)
1762: );
1763: break;
1764:
1765: case ParUnknownError :
1766:
1767: Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED;
1768: ParDump(
1769: PARDPC,
1770: ("PARALLEL: DPC - unknown error\n"
1771: "-------- STATUS/INFORMATON: %x/%x\n",
1772: Irp->IoStatus.Status,
1773: Irp->IoStatus.Information)
1774: );
1775: ParLogError(
1776: DeviceObject->DriverObject,
1777: DeviceObject,
1778: extension->OriginalController,
1779: ParPhysicalZero,
1780: extension->IrpSequence,
1781: irpSp->MajorFunction,
1782: 0,
1783: 38,
1784: Irp->IoStatus.Status,
1785: IO_ERR_NOT_READY
1786: );
1787: break;
1788:
1789: case ParBusy :
1790:
1791: Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
1792: Irp->IoStatus.Information = irpSp->Parameters.Write.Length -
1793: synchCount.OldCount;
1794: ParDump(
1795: PARDPC,
1796: ("PARALLEL: DPC - device busy\n"
1797: "-------- STATUS/INFORMATON: %x/%x\n",
1798: Irp->IoStatus.Status,
1799: Irp->IoStatus.Information)
1800: );
1801: break;
1802:
1803: case ParCancel:
1804:
1805: Irp->IoStatus.Status = STATUS_CANCELLED;
1806: Irp->IoStatus.Information = 0;
1807: ParDump(
1808: PARDPC,
1809: ("PARALLEL: DPC - cancel part of the case\n"
1810: "-------- STATUS/INFORMATON: %x/%x\n",
1811: Irp->IoStatus.Status,
1812: Irp->IoStatus.Information)
1813: );
1814: break;
1815:
1816:
1817: default :
1818:
1819: Irp->IoStatus.Status = STATUS_DEVICE_DATA_ERROR;
1820: ParDump(
1821: PARDPC,
1822: ("PARALLEL: DPC - default part of the case\n"
1823: "-------- STATUS/INFORMATON: %x/%x\n",
1824: Irp->IoStatus.Status,
1825: Irp->IoStatus.Information)
1826: );
1827: ParLogError(
1828: DeviceObject->DriverObject,
1829: DeviceObject,
1830: extension->OriginalController,
1831: ParPhysicalZero,
1832: extension->IrpSequence,
1833: irpSp->MajorFunction,
1834: 0,
1835: 39,
1836: Irp->IoStatus.Status,
1837: IO_ERR_NOT_READY
1838: );
1839: break;
1840: }
1841:
1842: IoStartNextPacket(
1843: DeviceObject,
1844: TRUE
1845: );
1846: ParDump(
1847: PARIRPCOMPLETE,
1848: ("PARALLEL: About to complete IRP: %x\n",Irp)
1849: );
1850: IoCompleteRequest(
1851: Irp,
1852: IO_PARALLEL_INCREMENT
1853: );
1854:
1855: }
1856:
1857: }
1858:
1859: BOOLEAN
1860: ParStartCriticalFunctions(
1861: IN PVOID Context
1862: )
1863:
1864: /*++
1865:
1866: Routine Description :
1867:
1868: This routine starts the writing operations on the device.
1869:
1870: Arguments :
1871:
1872: Context - Really a pointer to the device object for the parallel port
1873: device
1874:
1875: Return value :
1876:
1877: Always FALSE;
1878:
1879: --*/
1880:
1881: {
1882: PDEVICE_OBJECT deviceObject = Context;
1883: PIO_STACK_LOCATION irpSp =
1884: IoGetCurrentIrpStackLocation(deviceObject->CurrentIrp);
1885: PPAR_DEVICE_EXTENSION extension = deviceObject->DeviceExtension;
1886:
1887: extension->Command = ParWrite;
1888:
1889: //
1890: // Initialize the state machine for this packet so the remainder of the
1891: // driver can determine the number of characters that are to be written
1892: // to the device.
1893: //
1894:
1895: extension->CompletingIoControl = FALSE;
1896: extension->CountBuffer = irpSp->Parameters.Write.Length;
1897:
1898: //
1899: // patch for HP laserjet that hasn't INIT pin
1900: //
1901:
1902: if (!extension->Initialized) { //begin HP patch
1903:
1904: UCHAR deviceStatus = GetStatus(extension->Controller);
1905:
1906: ParDump(
1907: PARCRIT,
1908: ("PARALLEL: Critical - In HP patch\n")
1909: );
1910: if (PAR_OK(deviceStatus)) {
1911:
1912: ParDump(
1913: PARCRIT,
1914: ("PARALLEL: Critical - It was initialized\n")
1915: );
1916: extension->Initialized = TRUE;
1917:
1918: }
1919:
1920: } //end HP patch
1921:
1922:
1923: if (extension->Initialized) {
1924:
1925: ParDump(
1926: PARCRIT,
1927: ("PARALLEL: Critical - Sending a byte\n")
1928: );
1929: ParInitiateIo(deviceObject);
1930:
1931: } else {
1932:
1933: ParDump(
1934: PARCRIT,
1935: ("PARALLEL: Critical - reinitializing the device\n")
1936: );
1937: extension->AutoFeed = FALSE;
1938: ParInitializeDevice(extension);
1939:
1940: }
1941:
1942: //
1943: // If we are running off the timer then just
1944: // queue off the "polling" code.
1945: //
1946:
1947: if (extension->UsingATimer) {
1948:
1949: ParDump(
1950: PARCRIT,
1951: ("PARALLEL: Critical - queueing off the polling DPC\n")
1952: );
1953: KeInsertQueueDpc(
1954: &extension->PollingDpc,
1955: NULL,
1956: NULL
1957: );
1958:
1959: }
1960:
1961: return FALSE;
1962:
1963: }
1964:
1965: BOOLEAN
1966: ParManageIoDevice(
1967: IN PVOID Context
1968: )
1969:
1970: /*++
1971:
1972: Routine Description :
1973:
1974: This routine starts the IoControl commands.
1975:
1976: Arguments :
1977:
1978: Context - Really a pointer to a communication area between StartIo
1979: and ManageIoDevice
1980:
1981: Return Value :
1982:
1983: Always FALSE
1984:
1985: --*/
1986: {
1987: PCONTROL_AREA ioControlArea = Context;
1988: PPAR_DEVICE_EXTENSION extension = ioControlArea->Extension;
1989: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(ioControlArea->Irp);
1990:
1991: extension->CompletingIoControl = FALSE;
1992:
1993: if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
1994: IOCTL_PAR_SET_INFORMATION) {
1995:
1996: PPAR_SET_INFORMATION irpBuffer =
1997: ioControlArea->Irp->AssociatedIrp.SystemBuffer;
1998:
1999: extension->Command = ParSetInformation;
2000:
2001: extension->AutoFeed = (BOOLEAN)
2002: ((irpBuffer->Init & PARALLEL_AUTOFEED) != 0);
2003:
2004: ParInitializeDevice(extension);
2005:
2006: } else if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
2007: IOCTL_PAR_QUERY_INFORMATION) {
2008:
2009: ioControlArea->Status = GetStatus(extension->Controller);
2010: ioControlArea->Control = GetControl(extension->Controller);
2011: extension->Command = ParQueryInformation;
2012: extension->CompletingIoControl = TRUE;
2013:
2014: }
2015:
2016: return FALSE;
2017: }
2018:
2019: VOID
2020: ParStartIo(
2021: IN PDEVICE_OBJECT DeviceObject,
2022: IN PIRP Irp
2023: )
2024:
2025: /*++
2026:
2027: Routine Description:
2028:
2029: This routine starts an I/O operation for the driver and
2030: then returns
2031:
2032: Arguments:
2033:
2034: DeviceObject - Pointer to the device object of this device
2035:
2036: Irp - Pointer to the current IRP
2037:
2038: Return Value:
2039:
2040: None
2041:
2042: --*/
2043:
2044: {
2045: PPAR_DEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
2046: PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
2047:
2048: //
2049: // Increment the following value so that we can have a "unique"
2050: // value to give to the error log routine.
2051: //
2052:
2053: extension->IrpSequence++;
2054:
2055: ParDump(
2056: PARDISPATCH,
2057: ("PARALLEL: In startio with IRP: %x\n",
2058: Irp)
2059: );
2060: if (irpSp->MajorFunction == IRP_MJ_WRITE) {
2061:
2062: ParDump(
2063: PARSTART,
2064: ("PARALLEL - startio - Starting off a write\n")
2065: );
2066: ParSynchronizeExecution(
2067: extension,
2068: ParStartCriticalFunctions,
2069: DeviceObject
2070: );
2071:
2072: } else if (irpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL) {
2073:
2074: CONTROL_AREA ioControlArea;
2075:
2076: ioControlArea.Extension = extension;
2077: ioControlArea.Irp = Irp;
2078:
2079: ParDump(
2080: PARSTART,
2081: ("PARALLEL - startio - Starting off a device io control\n")
2082: );
2083: ParSynchronizeExecution(
2084: extension,
2085: ParManageIoDevice,
2086: &ioControlArea
2087: );
2088:
2089: if (irpSp->Parameters.DeviceIoControl.IoControlCode ==
2090: IOCTL_PAR_QUERY_INFORMATION) {
2091:
2092: PPAR_QUERY_INFORMATION irpBuffer = Irp->AssociatedIrp.SystemBuffer;
2093:
2094: ParDump(
2095: PARSTART,
2096: ("PARALLEL - startio - Starting off a query\n")
2097: );
2098: Irp->IoStatus.Status = STATUS_SUCCESS;
2099:
2100: //
2101: // Interpretating Status & Control
2102: //
2103:
2104: irpBuffer->Status = 0x0;
2105:
2106: if (PAR_POWERED_OFF(ioControlArea.Status) ||
2107: PAR_NO_CABLE(ioControlArea.Status)) {
2108:
2109: irpBuffer->Status =
2110: (UCHAR)(irpBuffer->Status | PARALLEL_POWER_OFF);
2111:
2112: } else if (PAR_PAPER_EMPTY(ioControlArea.Status)) {
2113:
2114: irpBuffer->Status =
2115: (UCHAR)(irpBuffer->Status | PARALLEL_PAPER_EMPTY);
2116:
2117: } else if (PAR_OFF_LINE(ioControlArea.Status)) {
2118:
2119: irpBuffer->Status =
2120: (UCHAR)(irpBuffer->Status | PARALLEL_OFF_LINE);
2121:
2122: } else if (PAR_NOT_CONNECTED(ioControlArea.Status)) {
2123:
2124: irpBuffer->Status =
2125: (UCHAR)(irpBuffer->Status | PARALLEL_NOT_CONNECTED);
2126:
2127: }
2128:
2129: if ( PAR_BUSY( ioControlArea.Status ) ) {
2130:
2131: irpBuffer->Status =
2132: (UCHAR)(irpBuffer->Status | PARALLEL_BUSY);
2133:
2134: }
2135:
2136: if (PAR_SELECTED(ioControlArea.Status)) {
2137:
2138: irpBuffer->Status =
2139: (UCHAR)(irpBuffer->Status | PARALLEL_SELECTED);
2140:
2141: }
2142:
2143: if (PAR_AUTOFEED(ioControlArea.Control)) {
2144:
2145: irpBuffer->Status =
2146: (UCHAR)(irpBuffer->Status | PARALLEL_AUTOFEED);
2147:
2148: }
2149:
2150: Irp->IoStatus.Information = sizeof( PAR_QUERY_INFORMATION );
2151: IoStartNextPacket(
2152: DeviceObject,
2153: TRUE
2154: );
2155: ParDump(
2156: PARIRPCOMPLETE,
2157: ("PARALLEL: About to complete IRP: %x\n",Irp)
2158: );
2159: IoCompleteRequest(
2160: Irp,
2161: IO_NO_INCREMENT
2162: );
2163:
2164: }
2165:
2166: }
2167:
2168: }
2169:
2170: BOOLEAN
2171: ParInitiateIo(
2172: IN PDEVICE_OBJECT DeviceObject
2173: )
2174:
2175: /*++
2176:
2177: Routine Description:
2178:
2179: This routine writes UCHARs to the parallel port device.
2180: It is called from StartCriticalFunctions and ISR. In other
2181: words, it fully expects to be synchronized with the isr.
2182:
2183: Arguments:
2184:
2185: DeviceObject - Pointer to the device object of the device
2186:
2187: Return Value:
2188:
2189: Always FALSE.
2190:
2191: --*/
2192:
2193: {
2194: PPAR_DEVICE_EXTENSION extension;
2195: PIRP irp;
2196: PIO_STACK_LOCATION irpSp;
2197: PUCHAR irpBuffer;
2198:
2199: extension = DeviceObject->DeviceExtension;
2200:
2201: if (extension->Initialized) {
2202:
2203: //
2204: // We only want to write to the port when the device is online.
2205: //
2206:
2207: UCHAR deviceStatus;
2208: ULONG numberWritten = 0;
2209: ULONG maxNumberToWrite;
2210:
2211: if (extension->InterruptMode = Latched) {
2212:
2213: maxNumberToWrite = 256;
2214:
2215: } else {
2216:
2217: maxNumberToWrite = 32;
2218:
2219: }
2220: irp = DeviceObject->CurrentIrp;
2221: irpSp = IoGetCurrentIrpStackLocation(irp);
2222: irpBuffer = (PUCHAR)(irp->AssociatedIrp.SystemBuffer);
2223: irpBuffer = &irpBuffer[irpSp->Parameters.Write.Length -
2224: extension->CountBuffer];
2225: do {
2226:
2227: deviceStatus = GetStatus(extension->Controller);
2228:
2229: if (PAR_ONLINE(deviceStatus)) {
2230:
2231: StoreData(
2232: extension->Controller,
2233: *irpBuffer
2234: );
2235:
2236: irpBuffer++;
2237: extension->CountBuffer--;
2238: numberWritten++;
2239:
2240: } else {
2241:
2242: ParDump(
2243: PARCRIT,
2244: ("PARALLEL: Initiate IO - device is not on line, status: %x\n",
2245: deviceStatus)
2246: );
2247:
2248: break;
2249:
2250: }
2251:
2252: } while (extension->CountBuffer && (numberWritten < maxNumberToWrite));
2253:
2254: }
2255: extension->TimerCount = extension->TimerStart;
2256: return FALSE;
2257: }
2258:
2259: VOID
2260: ParCancelRequest(
2261: PDEVICE_OBJECT DeviceObject,
2262: PIRP Irp
2263: )
2264:
2265: /*++
2266:
2267: Routine Description:
2268:
2269: This routine is used to cancel any request in the parallel driver.
2270:
2271: Arguments:
2272:
2273: DeviceObject - Pointer to the device object for this device
2274:
2275: Irp - Pointer to the IRP to be canceled.
2276:
2277: Return Value:
2278:
2279: None.
2280:
2281: --*/
2282:
2283: {
2284:
2285: //
2286: // If this is the current request then just let normal
2287: // code detect that the current is cancelled.
2288: //
2289: // If this isn't the current request then remove the request
2290: // from the device queue and complete it.
2291: //
2292:
2293: if (Irp != DeviceObject->CurrentIrp) {
2294:
2295: KeRemoveEntryDeviceQueue(
2296: &DeviceObject->DeviceQueue,
2297: &Irp->Tail.Overlay.DeviceQueueEntry
2298: );
2299:
2300: Irp->IoStatus.Status = STATUS_CANCELLED;
2301: Irp->IoStatus.Information = 0;
2302:
2303: IoReleaseCancelSpinLock(Irp->CancelIrql);
2304:
2305: ParDump(
2306: PARIRPCOMPLETE,
2307: ("PARALLEL: About to complete IRP: %x\n",Irp)
2308: );
2309: IoCompleteRequest(
2310: Irp,
2311: IO_NO_INCREMENT
2312: );
2313:
2314: } else {
2315:
2316: ParDump(
2317: PARIRPCOMPLETE,
2318: ("PARALLEL: Can't complete (CANCEL) IRP: %x because it's current\n",
2319: Irp)
2320: );
2321: IoReleaseCancelSpinLock(Irp->CancelIrql);
2322:
2323: }
2324:
2325: }
2326:
2327: BOOLEAN
2328: ParSynchronizeExecution(
2329: IN PPAR_DEVICE_EXTENSION Extension,
2330: IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
2331: IN PVOID SynchronizeContext
2332: )
2333:
2334: /*++
2335:
2336: Routine Description:
2337:
2338: This routine is used to abstract whether we are using
2339: an interrupt object or a simple spin lock.
2340:
2341: Arguments:
2342:
2343: Extension - The device extension for the port.
2344:
2345: SynchronizeRoutine - A routine to call when the lock
2346: is aquired.
2347:
2348: SynchronizeContext - What to pass to the synchronization
2349: routine.
2350:
2351: Return Value:
2352:
2353: Whatever the synchronization routine returns.
2354:
2355: --*/
2356:
2357: {
2358:
2359: KIRQL oldIrql;
2360: BOOLEAN returnValue;
2361:
2362: KeAcquireSpinLock(
2363: &Extension->PollingLock,
2364: &oldIrql
2365: );
2366:
2367: if (Extension->Interrupt) {
2368:
2369: //
2370: // If we've haven't dropped down to using a timer
2371: // then the acquiring the polling lock is a bit
2372: // of extra overhead, but hopefully not too harmful.
2373: // We did have to pass through this irql anyway.
2374: //
2375:
2376: if (!Extension->UsingATimer) {
2377:
2378: //
2379: // We have a small race where the isr is just about
2380: // to set this to true. This is not really a big deal.
2381: // We will simply synchronize once using the interrupt
2382: // object and thereafter use the PollingLock. Overall
2383: // we are always protected by the polling lock.
2384: //
2385:
2386: returnValue = KeSynchronizeExecution(
2387: Extension->Interrupt,
2388: SynchronizeRoutine,
2389: SynchronizeContext
2390: );
2391:
2392: } else {
2393:
2394: returnValue = SynchronizeRoutine(
2395: SynchronizeContext
2396: );
2397:
2398: }
2399:
2400: } else {
2401:
2402: returnValue = SynchronizeRoutine(
2403: SynchronizeContext
2404: );
2405:
2406: }
2407:
2408: KeReleaseSpinLock(
2409: &Extension->PollingLock,
2410: oldIrql
2411: );
2412:
2413: return returnValue;
2414:
2415: }
2416:
2417: VOID
2418: ParPollingDpcRoutine(
2419: IN PKDPC Dpc,
2420: IN PVOID DeferredContext,
2421: IN PVOID SystemContext1,
2422: IN PVOID SystemContext2
2423: )
2424:
2425: /*++
2426:
2427: Routine Description:
2428:
2429: This routine is invoked by the polling timer. It will
2430: call the parsynchronizeexecution routine to call the
2431: real polling routine.
2432:
2433: Arguments:
2434:
2435: Dpc - Not Used.
2436:
2437: DeferredContext - Really points to the device extension.
2438:
2439: SystemContext1 - Not Used.
2440:
2441: SystemContext2 - Not Used.
2442:
2443: Return Value:
2444:
2445: None.
2446:
2447: --*/
2448:
2449: {
2450:
2451: PPAR_DEVICE_EXTENSION extension = DeferredContext;
2452:
2453: UNREFERENCED_PARAMETER(Dpc);
2454: UNREFERENCED_PARAMETER(SystemContext1);
2455: UNREFERENCED_PARAMETER(SystemContext2);
2456:
2457: ParSynchronizeExecution(
2458: extension,
2459: ParPolling,
2460: extension
2461: );
2462:
2463: }
2464:
2465: BOOLEAN
2466: ParPolling(
2467: IN PVOID Context
2468: )
2469:
2470: /*++
2471:
2472: Routine Description:
2473:
2474: This routine is used to drive write requests on a device
2475: that doesn't isn't using interrupts.
2476:
2477: Arguments:
2478:
2479: Context - really a pointer to the device extension
2480:
2481: Return Value:
2482:
2483: None.
2484:
2485: --*/
2486:
2487: {
2488:
2489: PPAR_DEVICE_EXTENSION extension = Context;
2490: KIRQL oldIrql;
2491: ULONG callToIsr;
2492: ULONG ticks;
2493: #define MAXTICKSTOWAIT 10000
2494: #define MINTICKSTOWAIT 1
2495: #define MAXTIMESCALLTOISR 10000
2496: #define MAXMIKESINHERE 100000
2497: ULONG maxTimesCallToIsr = MAXTIMESCALLTOISR;
2498: ULONG maxTicksToWait = MAXTICKSTOWAIT;
2499:
2500: //
2501: // We try to call the isr maxTimesCallToIsr per each invocation
2502: // of this routine.
2503: //
2504:
2505: ParDump(
2506: PARPOLLREPORT,
2507: ("PARALLEL: Chars starting poll: %d\n",
2508: extension->CountBuffer)
2509: );
2510: ParDump(
2511: PARPOLLREPORT,
2512: ("PARALLEL: Polling irp is: %x\n",
2513: extension->DeviceObject->CurrentIrp)
2514: );
2515:
2516: //
2517: // If there isn't a current irp (like it got canceled somehow)
2518: // then simply get out. This is only to write chars for the current
2519: // irp.
2520: //
2521:
2522: if (!extension->DeviceObject->CurrentIrp) {
2523:
2524: return FALSE;
2525:
2526: }
2527:
2528: for (
2529: callToIsr = 0;
2530: callToIsr < maxTimesCallToIsr;
2531: callToIsr++
2532: ) {
2533:
2534: //
2535: // We are willing to wait up to MAXTICKSTOWAIT uS "ticks" for each
2536: // call to the ISR to do something useful.
2537: //
2538:
2539: for (
2540: ticks = 0;
2541: ticks < maxTicksToWait;
2542: ticks++
2543: ) {
2544:
2545: if (ParInterruptServiceRoutine(
2546: extension->Interrupt,
2547: extension->DeviceObject
2548: )) {
2549:
2550: //
2551: // We'll we got something done. If the timercount
2552: // is -1 then means we are completing the operation
2553: // somehow. If we are completing, let the normal
2554: // completion code do its work.
2555: //
2556:
2557: if (extension->TimerCount == -1) {
2558:
2559: ParDump(
2560: PARPOLLREPORT,
2561: ("PARALLEL: Polling says we're done\n")
2562: );
2563: return FALSE;
2564:
2565: }
2566:
2567: //
2568: // Got did something useful. Go for more.
2569: //
2570: // If this is the second time we did something then
2571: // adjust the amount of work we do in this routine
2572: // based on how long it took the call to work.
2573: // We do the second call because the first call might have
2574: // been influenced by the fact that this we sitting in the
2575: // timer queue for a while and this lets the device get
2576: // all caught up.
2577: //
2578:
2579: if (callToIsr == 1) {
2580:
2581: if (ticks < MINTICKSTOWAIT) {
2582:
2583: ticks = MINTICKSTOWAIT;
2584:
2585: }
2586:
2587: //
2588: // The maximum amount of time we want to spend
2589: // in here is MAXMIKESINHERE. We divide it by
2590: // the number of ticks it took for the second
2591: // call to the isr.
2592: //
2593:
2594: maxTicksToWait = ticks;
2595:
2596: maxTimesCallToIsr = MAXMIKESINHERE / maxTicksToWait;
2597:
2598: if (maxTimesCallToIsr > MAXTIMESCALLTOISR) {
2599:
2600: //
2601: // If we are on a really fast machine, or
2602: // we are on a really fast printer (or both) let's
2603: // not use up our full "slice". Let's get out
2604: // after MAXTIMESCALLTOISR.
2605: //
2606:
2607: maxTimesCallToIsr = MAXTIMESCALLTOISR;
2608:
2609: }
2610:
2611: }
2612: goto doNextCallToIsr;
2613:
2614: } else {
2615:
2616: //
2617: // Not ready yet. Stall for a microsecond.
2618: //
2619:
2620: KeStallExecutionProcessor(1);
2621:
2622: }
2623:
2624: }
2625:
2626: //
2627: // We didn't write the character within the amount
2628: // of time allocated. Break out of the outer loop
2629: //
2630:
2631: break;
2632:
2633: doNextCallToIsr: ;
2634:
2635: }
2636:
2637: //
2638: // All done trying to write characters. Queue a timer to invoke us
2639: // again.
2640: //
2641:
2642: KeSetTimer(
2643: &extension->PollingTimer,
2644: extension->PollingDelayAmount,
2645: &extension->PollingDpc
2646: );
2647:
2648: ParDump(
2649: PARPOLLREPORT,
2650: ("PARALLEL: To go at end of poll: %d\n"
2651: "--------- Ticks per char is: %d\n"
2652: "--------- Calls to isr per: %d\n",
2653: extension->CountBuffer,
2654: maxTicksToWait,
2655: maxTimesCallToIsr)
2656:
2657: );
2658:
2659: return FALSE;
2660: #undef MAXTICKSTOWAIT
2661: #undef MINTICKSTOWAIT
2662: #undef MAXTIMESCALLTOISR
2663: #undef MAXMIKESINHERE
2664: }
2665:
2666: VOID
2667: ParStartBusyTimer(
2668: IN PKDPC Dpc,
2669: IN PVOID DeferredContext,
2670: IN PVOID SystemContext1,
2671: IN PVOID SystemContext2
2672: )
2673:
2674: /*++
2675:
2676: Routine Description:
2677:
2678: This routine is invoked by the dpc that is queued by the
2679: ISR when it finds that it has work to do yet the status
2680: is busy.
2681:
2682: Arguments:
2683:
2684: Dpc - Not Used.
2685:
2686: DeferredContext - Really points to the device extension.
2687:
2688: SystemContext1 - Not Used.
2689:
2690: SystemContext2 - Not Used.
2691:
2692: Return Value:
2693:
2694: None.
2695:
2696: --*/
2697:
2698: {
2699:
2700: PPAR_DEVICE_EXTENSION extension = DeferredContext;
2701:
2702: UNREFERENCED_PARAMETER(Dpc);
2703: UNREFERENCED_PARAMETER(SystemContext1);
2704: UNREFERENCED_PARAMETER(SystemContext2);
2705:
2706: ParDump(
2707: PARBUSYPATH,
2708: ("Parallel: In start busy timer dpc\n")
2709: );
2710: KeSetTimer(
2711: &extension->BusyTimer,
2712: extension->BusyDelayAmount,
2713: &extension->BusyTimerDpc
2714: );
2715:
2716: }
2717:
2718: VOID
2719: ParBusyTimer(
2720: IN PKDPC Dpc,
2721: IN PVOID DeferredContext,
2722: IN PVOID SystemContext1,
2723: IN PVOID SystemContext2
2724: )
2725:
2726: /*++
2727:
2728: Routine Description:
2729:
2730: This routine is invoked by the dpc that is queued by when
2731: the busy timer fires.
2732:
2733: Arguments:
2734:
2735: Dpc - Not Used.
2736:
2737: DeferredContext - Really points to the device extension.
2738:
2739: SystemContext1 - Not Used.
2740:
2741: SystemContext2 - Not Used.
2742:
2743: Return Value:
2744:
2745: None.
2746:
2747: --*/
2748:
2749: {
2750:
2751: PPAR_DEVICE_EXTENSION extension = DeferredContext;
2752:
2753: UNREFERENCED_PARAMETER(Dpc);
2754: UNREFERENCED_PARAMETER(SystemContext1);
2755: UNREFERENCED_PARAMETER(SystemContext2);
2756:
2757: ParDump(
2758: PARBUSYPATH,
2759: ("Parallel: In busy timer dpc\n")
2760: );
2761: ParSynchronizeExecution(
2762: extension,
2763: ParBusyCallIsr,
2764: extension
2765: );
2766:
2767: }
2768:
2769: BOOLEAN
2770: ParBusyCallIsr(
2771: IN PVOID Context
2772: )
2773:
2774: /*++
2775:
2776: Routine Description:
2777:
2778: This routine is invoked via KeSynchronize execution which
2779: was invoked by the dpc associated with the busy timer.
2780: Its sole purpose is to call the interrupt service routine.
2781:
2782: Arguments:
2783:
2784: Context - Really a pointer to the device extension.
2785:
2786: Return Value:
2787:
2788: Always False.
2789:
2790: --*/
2791:
2792: {
2793:
2794: PPAR_DEVICE_EXTENSION extension = Context;
2795:
2796: extension->BusyPath = FALSE;
2797:
2798: ParDump(
2799: PARBUSYPATH,
2800: ("Parallel: In busy timer - about to call isr\n")
2801: );
2802: ParInterruptServiceRoutine(
2803: extension->Interrupt,
2804: extension->DeviceObject
2805: );
2806:
2807: return FALSE;
2808:
2809: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.