![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to par.h 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 par.h CVS log | Up to [WindowsNT SDKs] / ntddk / src / comm / oldpar |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1990, 1991 Microsoft Corporation ! 4: ! 5: Module Name : ! 6: ! 7: par.h ! 8: ! 9: Abstract: ! 10: ! 11: Type definitions and data for the parallel port driver ! 12: ! 13: Author: ! 14: ! 15: ! 16: Revision History: ! 17: --*/ ! 18: ! 19: ! 20: #if DBG ! 21: #define PARCONFIG ((ULONG)0x00000001) ! 22: #define PARUNLOAD ((ULONG)0x00000002) ! 23: #define PARINITDEV ((ULONG)0x00000004) ! 24: #define PARTIMEOUT ((ULONG)0x00000008) ! 25: #define PARSTART ((ULONG)0x00000010) ! 26: #define PARISR ((ULONG)0x00000020) ! 27: #define PARDPC ((ULONG)0x00000040) ! 28: #define PARCRIT ((ULONG)0x00000080) ! 29: #define PARBUSYPATH ((ULONG)0x00000100) ! 30: #define PARIRPCOMPLETE ((ULONG)0x00000200) ! 31: #define PARDISPATCH ((ULONG)0x00000400) ! 32: #define PARISRACTION ((ULONG)0x00000800) ! 33: #define PARPOLLREPORT ((ULONG)0x00001000) ! 34: #define PARERRORS ((ULONG)0x40000000) ! 35: #define PARBUGCHECK ((ULONG)0x80000000) ! 36: extern ULONG ParDebugLevel; ! 37: #define ParDump(LEVEL,STRING) \ ! 38: do { \ ! 39: ULONG _level = (LEVEL); \ ! 40: if (ParDebugLevel & _level) { \ ! 41: DbgPrint STRING; \ ! 42: } \ ! 43: if (_level == PARBUGCHECK) { \ ! 44: ASSERT(FALSE); \ ! 45: } \ ! 46: } while (0) ! 47: #else ! 48: #define ParDump(LEVEL,STRING) do {NOTHING;} while (0) ! 49: #endif ! 50: ! 51: // ! 52: // This define gives the default Object directory ! 53: // that we should use to insert the symbolic links ! 54: // between the NT device name and namespace used by ! 55: // that object directory. ! 56: #define DEFAULT_DIRECTORY L"DosDevices" ! 57: ! 58: // ! 59: // For the above directory, the serial port will ! 60: // use the following name as the suffix of the serial ! 61: // ports for that directory. It will also append ! 62: // a number onto the end of the name. That number ! 63: // will start at 1. ! 64: #define DEFAULT_PARALLEL_NAME L"LPT" ! 65: // ! 66: // ! 67: // This define gives the default NT name for ! 68: // for serial ports detected by the firmware. ! 69: // This name will be appended to Device prefix ! 70: // with a number following it. The number is ! 71: // incremented each time encounter a serial ! 72: // port detected by the firmware. Note that ! 73: // on a system with multiple busses, this means ! 74: // that the first port on a bus is not necessarily ! 75: // \Device\Parallel0. ! 76: // ! 77: #define DEFAULT_NT_SUFFIX L"Parallel" ! 78: ! 79: ! 80: // ! 81: // Defines the number of interrupts it takes for us to decide that ! 82: // we have an interrupt storm on machine ! 83: // ! 84: #define PARALLEL_STORM_WATCH 500 ! 85: ! 86: #define PARALLEL_DATA_OFFSET 0 ! 87: #define PARALLEL_STATUS_OFFSET 1 ! 88: #define PARALLEL_CONTROL_OFFSET 2 ! 89: #define PARALLEL_REGISTER_SPAN 3 ! 90: ! 91: typedef struct _CONFIG_DATA { ! 92: // ! 93: // This list entry is used to link all of the "valid" ! 94: // configuration entries together. ! 95: // ! 96: LIST_ENTRY ConfigList; ! 97: ! 98: // ! 99: // The nt object directory into which to place the symbolic ! 100: // link to this port. ! 101: // ! 102: UNICODE_STRING ObjectDirectory; ! 103: ! 104: // ! 105: // The suffix to be used in the nt device name space for this ! 106: // port. ! 107: // ! 108: UNICODE_STRING NtNameForPort; ! 109: ! 110: // ! 111: // The name to be symbolic linked to the nt name. ! 112: // ! 113: UNICODE_STRING SymbolicLinkName; ! 114: ! 115: // ! 116: // The base address of the registry set for this device. ! 117: // ! 118: PHYSICAL_ADDRESS Controller; ! 119: ! 120: // ! 121: // The number of contiguous bytes take up by the register ! 122: // set for the device. ! 123: // ! 124: ULONG SpanOfController; ! 125: ! 126: // ! 127: // The bus number (with respect to the bus type) of the bus ! 128: // that this device occupies. ! 129: // ! 130: ULONG BusNumber; ! 131: ! 132: // ! 133: // Denotes whether this devices physical addresses live in io space ! 134: // or memory space. ! 135: // ! 136: ULONG AddressSpace; ! 137: ! 138: // ! 139: // Denotes whether this device is latched or level sensitive. ! 140: // ! 141: KINTERRUPT_MODE InterruptMode; ! 142: ! 143: // ! 144: // The kind of bus that this device lives on (e.g. Isa, Eisa, MCA, etc) ! 145: // ! 146: INTERFACE_TYPE InterfaceType; ! 147: ! 148: // ! 149: // The originalirql is what is optained from the firmware data. The level ! 150: // is also obtained from the firmware data. When we get a configuration ! 151: // record based on the services portion of the registry we will always set ! 152: // the vector equal to the irql unless overridden by user input. ! 153: // ! 154: ULONG OriginalVector; ! 155: ULONG OriginalIrql; ! 156: ! 157: // ! 158: // Denotes whether the device should be disabled after it has been ! 159: // initialized. ! 160: // ! 161: ULONG DisablePort; ! 162: ! 163: } CONFIG_DATA,*PCONFIG_DATA; ! 164: ! 165: typedef enum _PAR_COMMAND { ! 166: ParWrite, ! 167: ParSetInformation, ! 168: ParQueryInformation ! 169: } PAR_COMMAND, *PPAR_COMMAND; ! 170: ! 171: typedef struct _PAR_DEVICE_EXTENSION { ! 172: ! 173: // ! 174: // For reporting resource usage, we keep around the physical ! 175: // address we got from the registry. ! 176: // ! 177: PHYSICAL_ADDRESS OriginalController; ! 178: ! 179: // ! 180: // We keep a pointer around to our device name for dumps ! 181: // and for creating "external" symbolic links to this ! 182: // device. ! 183: // ! 184: UNICODE_STRING DeviceName; ! 185: ! 186: // ! 187: // This points to the object directory that we will place ! 188: // a symbolic link to our device name. ! 189: // ! 190: UNICODE_STRING ObjectDirectory; ! 191: ! 192: // ! 193: // This points to the device name for this device ! 194: // sans device prefix. ! 195: // ! 196: UNICODE_STRING NtNameForPort; ! 197: ! 198: // ! 199: // This points to the symbolic link name that will be ! 200: // linked to the actual nt device name. ! 201: // ! 202: UNICODE_STRING SymbolicLinkName; ! 203: ! 204: // ! 205: // Points to the device object that contains ! 206: // this device extension. ! 207: // ! 208: PDEVICE_OBJECT DeviceObject; ! 209: ! 210: // ! 211: // For value -1 when the interval timer maintained by the IO system ! 212: // fires, it implies that the timer routine is to do nothing. ! 213: // ! 214: // For value 0, then the timer routine should timeout the particular ! 215: // operation. ! 216: // ! 217: // For values > 0 then the timer should do nothing other then synchronize ! 218: // with the isr and decrement this value by 1. ! 219: // ! 220: LONG TimerCount; ! 221: ! 222: // ! 223: // This holds the current value to initialize TimerCount ! 224: // to when an operation starts. ! 225: // ! 226: ULONG TimerStart; ! 227: ! 228: // ! 229: // Unexpected interrupts are counted here. It is cleared ! 230: // every second by the timer management routine. On ! 231: // a device that is being interrupt driven, if the unexpected ! 232: // interrupt count exceeds a threshold, the interrupts will ! 233: // be disabled on the device and the device will go to polled ! 234: // mode. ! 235: // ! 236: ULONG UnexpectedCount; ! 237: ! 238: // ! 239: // The base address for the set of device registers ! 240: // of the port. ! 241: // ! 242: PUCHAR Controller; ! 243: ! 244: // ! 245: // Points to the interrupt object used by this device. ! 246: // ! 247: PKINTERRUPT Interrupt; ! 248: ! 249: // ! 250: // This value holds the span (in units of bytes) of the register ! 251: // set controlling this port. This is constant over the life ! 252: // of the port. ! 253: // ! 254: ULONG SpanOfController; ! 255: ! 256: // ! 257: // Set at intialization to indicate that on the current ! 258: // architecture we need to unmap the base register address ! 259: // when we unload the driver. ! 260: // ! 261: BOOLEAN UnMapRegisters; ! 262: ! 263: // ! 264: // These two variables denote the "staging" of initializing the ! 265: // device. Some devices won't respond with an interrupt when ! 266: // initializing. When we start initializing, we set the Initializing ! 267: // variable to TRUE and the Initialized flag to FALES. ! 268: // ! 269: // Whenever we go an access the hardware we check the initializing flag. ! 270: // If it is true, then we check the "status" of the device, and if the ! 271: // everything is ok, set initializing to FALSE and Initialized to TRUE. ! 272: // If the "status" of the device is not "good", then we process it as an ! 273: // error, and return the error indication to the caller. ! 274: // ! 275: BOOLEAN Initialized; ! 276: BOOLEAN Initializing; ! 277: ! 278: // ! 279: // This denotes the number of characters left in the current write. ! 280: // ! 281: ULONG CountBuffer; ! 282: ! 283: BOOLEAN AutoFeed; ! 284: BOOLEAN CompletingIoControl; ! 285: ! 286: // ! 287: // Records whether we actually created the symbolic link name ! 288: // at driver load time. If we didn't create it, we won't try ! 289: // to distroy it when we unload. ! 290: // ! 291: BOOLEAN CreatedSymbolicLink; ! 292: ! 293: // ! 294: // This field will denote that the driver is using a timer instead of ! 295: // interrupts to "schedule" work out to the device. ! 296: // ! 297: BOOLEAN UsingATimer; ! 298: ! 299: PAR_COMMAND Command; ! 300: ! 301: // ! 302: // Says whether this device can share interrupts with devices ! 303: // other than parallel devices. ! 304: // ! 305: BOOLEAN InterruptShareable; ! 306: ! 307: // ! 308: // Denotes to the timer routine whether it should log an error ! 309: // because we were blasted by to many interrupts. ! 310: // ! 311: BOOLEAN StormKnocksOutInterrupts; ! 312: ! 313: // ! 314: // We keep the following values around so that we can connect ! 315: // to the interrupt and report resources after the configuration ! 316: // record is gone. ! 317: // ! 318: // ! 319: // The following two values are obtained from HalGetInterruptVector ! 320: // ! 321: ULONG Vector; ! 322: KIRQL Irql; ! 323: ! 324: // ! 325: // The following two values are what is obtained (or deduced) from either ! 326: // the firmware created portion of the registry, or the user data. ! 327: // ! 328: ULONG OriginalVector; ! 329: ULONG OriginalIrql; ! 330: ! 331: // ! 332: // This is either what is deduced from the particular bus this port is ! 333: // on, or overridden by what the user placed in the registry. ! 334: // ! 335: KINTERRUPT_MODE InterruptMode; ! 336: ! 337: // ! 338: // Give back by HalGetInterruptVector. This says what processors this ! 339: // device can interrupt to. ! 340: // ! 341: KAFFINITY ProcessorAffinity; ! 342: ! 343: // ! 344: // The next three are supplied by the firmware or overridden by the user. ! 345: // ! 346: ULONG AddressSpace; ! 347: ULONG BusNumber; ! 348: INTERFACE_TYPE InterfaceType; ! 349: ! 350: // ! 351: // All irps go through the start io routine. Whenver ! 352: // we start out a new irp we increment this value. This ! 353: // is how we can have a unique irp value to give if we ! 354: // need to log an error during the processing of a particular ! 355: // irp. ! 356: // ! 357: ULONG IrpSequence; ! 358: ! 359: // ! 360: // This spinlock is used to synchronize access to the hardware ! 361: // when the port is being driver off of a timer, rather than ! 362: // when using interrupts. ! 363: // ! 364: KSPIN_LOCK PollingLock; ! 365: ! 366: // ! 367: // We use a timer so that we can try to do a bunch of ! 368: // operations, then give the rest of the system time ! 369: // to run ! 370: // ! 371: KTIMER PollingTimer; ! 372: ! 373: // ! 374: // This dpc is queued when the polling timer expires, and it is ! 375: // also queued after we start a write operations. ! 376: // ! 377: KDPC PollingDpc; ! 378: ! 379: // ! 380: // This is the length of time the timer will spend in the ! 381: // timer queue. ! 382: // ! 383: LARGE_INTEGER PollingDelayAmount; ! 384: ! 385: // ! 386: // This timer is used for polling the busy bit. ! 387: // ! 388: KTIMER BusyTimer; ! 389: ! 390: // ! 391: // This dpc is queued from the isr to start the above timer. ! 392: // ! 393: KDPC StartBusyTimerDpc; ! 394: ! 395: // ! 396: // This is the dpc queued when the above timer fires. ! 397: // ! 398: KDPC BusyTimerDpc; ! 399: ! 400: // ! 401: // This holds the delta time fed to above timer. ! 402: // ! 403: LARGE_INTEGER BusyDelayAmount; ! 404: ! 405: // ! 406: // We keep this boolean around to tell use that we've started off ! 407: // the busy "path of execution". If this variable is true when ! 408: // the isr would start off the busy path, it won't start it. If ! 409: // it is false, we set it to true and start the path. It is not ! 410: // set back to false until just before the path calls back the ! 411: // isr. ! 412: // ! 413: BOOLEAN BusyPath; ! 414: } PAR_DEVICE_EXTENSION, *PPAR_DEVICE_EXTENSION; ! 415: ! 416: // ! 417: // Bit Definitions in the status register. ! 418: // ! 419: ! 420: #define PAR_STATUS_NOT_ERROR 0x08 //not error on device ! 421: #define PAR_STATUS_SLCT 0x10 //device is selected (on-line) ! 422: #define PAR_STATUS_PE 0x20 //paper empty ! 423: #define PAR_STATUS_NOT_ACK 0x40 //not acknowledge (data transfer was not ok) ! 424: #define PAR_STATUS_NOT_BUSY 0x80 //operation in progress ! 425: ! 426: // ! 427: // Bit Definitions in the control register. ! 428: // ! 429: ! 430: #define PAR_CONTROL_STROBE 0x01 //to read or write data ! 431: #define PAR_CONTROL_AUTOFD 0x02 //to autofeed continuous form paper ! 432: #define PAR_CONTROL_NOT_INIT 0x04 //begin an initialization routine ! 433: #define PAR_CONTROL_SLIN 0x08 //to select the device ! 434: #define PAR_CONTROL_IRQ_ENB 0x10 //to enable interrupts ! 435: #define PAR_CONTROL_DIR 0x20 //direction = read ! 436: #define PAR_CONTROL_WR_CONTROL 0xc0 //the 2 highest bits of the control ! 437: // register must be 1 ! 438: ! 439: //VOID StoreData( ! 440: // IN PUCHAR RegisterBase, ! 441: // IN UCHAR DataByte ! 442: // ) ! 443: //Data must be on line before Strobe = 1; ! 444: // Strobe = 1, DIR = 0 ! 445: //Strobe = 0 ! 446: // ! 447: // We change the port direction to output (and make sure stobe is low). ! 448: // ! 449: // Note that the data must be available at the port for at least ! 450: // .5 microseconds before and after you strobe, and that the strobe ! 451: // must be active for at least 500 nano seconds. We are going ! 452: // to end up stalling for twice as much time as we need to, but, there ! 453: // isn't much we can do about that. ! 454: // ! 455: // We put the data into the port and wait for 1 micro. ! 456: // We strobe the line for at least 1 micro ! 457: // We lower the strobe and again delay for 1 micro ! 458: // We then revert to the original port direction. ! 459: // ! 460: // Thanks to Olivetti for advice. ! 461: // ! 462: ! 463: #define StoreData(RegisterBase,DataByte) \ ! 464: { \ ! 465: PUCHAR _Address = RegisterBase; \ ! 466: UCHAR _Control; \ ! 467: _Control = GetControl(_Address); \ ! 468: ASSERT(!(_Control & PAR_CONTROL_STROBE)); \ ! 469: StoreControl( \ ! 470: _Address, \ ! 471: (UCHAR)(_Control & ~(PAR_CONTROL_STROBE | PAR_CONTROL_DIR)) \ ! 472: ); \ ! 473: WRITE_PORT_UCHAR( \ ! 474: _Address+PARALLEL_DATA_OFFSET, \ ! 475: (UCHAR)DataByte \ ! 476: ); \ ! 477: KeStallExecutionProcessor((ULONG)1); \ ! 478: StoreControl( \ ! 479: _Address, \ ! 480: (UCHAR)((_Control | PAR_CONTROL_STROBE) & ~PAR_CONTROL_DIR) \ ! 481: ); \ ! 482: KeStallExecutionProcessor((ULONG)1); \ ! 483: StoreControl( \ ! 484: _Address, \ ! 485: (UCHAR)(_Control & ~(PAR_CONTROL_STROBE | PAR_CONTROL_DIR)) \ ! 486: ); \ ! 487: KeStallExecutionProcessor((ULONG)1); \ ! 488: StoreControl( \ ! 489: _Address, \ ! 490: (UCHAR)_Control \ ! 491: ); \ ! 492: } ! 493: ! 494: //UCHAR ! 495: //GetControl( ! 496: // IN PUCHAR RegisterBase ! 497: // ) ! 498: #define GetControl(RegisterBase) \ ! 499: (READ_PORT_UCHAR((RegisterBase)+PARALLEL_CONTROL_OFFSET)) ! 500: ! 501: ! 502: //VOID ! 503: //StoreControl( ! 504: // IN PUCHAR RegisterBase, ! 505: // IN UCHAR ControlByte ! 506: // ) ! 507: #define StoreControl(RegisterBase,ControlByte) \ ! 508: { \ ! 509: WRITE_PORT_UCHAR( \ ! 510: (RegisterBase)+PARALLEL_CONTROL_OFFSET, \ ! 511: (UCHAR)ControlByte \ ! 512: ); \ ! 513: } ! 514: ! 515: ! 516: //UCHAR ! 517: //GetStatus( ! 518: // IN PUCHAR RegisterBase ! 519: // ) ! 520: ! 521: #define GetStatus(RegisterBase) \ ! 522: (READ_PORT_UCHAR((RegisterBase)+PARALLEL_STATUS_OFFSET)) ! 523: ! 524: typedef enum _PAR_ERROR_TYPE { ! 525: PoweredOff, ! 526: NotConnected, ! 527: Offline, ! 528: PaperEmpty, ! 529: PowerFailure, ! 530: DataError, ! 531: Busy ! 532: } PAR_ERROR_TYPE, *PPAR_ERROR_TYPE; ! 533: ! 534: BOOLEAN ! 535: ParInitializeDevice( ! 536: IN PVOID Context ! 537: ); ! 538: ! 539: NTSTATUS ! 540: ParDispatch( ! 541: IN PDEVICE_OBJECT DeviceObject, ! 542: IN PIRP Irp ! 543: ); ! 544: ! 545: NTSTATUS ! 546: ParSetInformationFile( ! 547: IN PDEVICE_OBJECT DeviceObject, ! 548: IN PIRP Irp ! 549: ); ! 550: ! 551: NTSTATUS ! 552: ParQueryInformationFile( ! 553: IN PDEVICE_OBJECT DeviceObject, ! 554: IN PIRP Irp ! 555: ); ! 556: ! 557: VOID ! 558: ParDpcRoutine( ! 559: IN PKDPC Dpc, ! 560: IN PDEVICE_OBJECT DeviceObject, ! 561: IN PIRP Irp, ! 562: IN PVOID Context ! 563: ); ! 564: ! 565: VOID ! 566: ParTimerRoutine( ! 567: PDEVICE_OBJECT DeviceObject, ! 568: IN PVOID Context ! 569: ); ! 570: ! 571: BOOLEAN ! 572: ParManageTimeOut( ! 573: IN PVOID Context ! 574: ); ! 575: ! 576: BOOLEAN ! 577: ParInterruptServiceRoutine( ! 578: IN PKINTERRUPT InterruptObject, ! 579: IN PVOID Context ! 580: ); ! 581: ! 582: BOOLEAN ! 583: ParInitiateIo( ! 584: IN PDEVICE_OBJECT DeviceObject ! 585: ); ! 586: ! 587: VOID ! 588: ParStartIo( ! 589: IN PDEVICE_OBJECT DeviceObject, ! 590: IN PIRP Irp ! 591: ); ! 592: ! 593: VOID ! 594: ParUnload( ! 595: IN PDRIVER_OBJECT DriverObject ! 596: ); ! 597: ! 598: VOID ! 599: ParCancelRequest( ! 600: IN PDEVICE_OBJECT DeviceObject, ! 601: IN PIRP Irp ! 602: ); ! 603: ! 604: BOOLEAN ! 605: ParSynchronizeExecution( ! 606: IN PPAR_DEVICE_EXTENSION Extension, ! 607: IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, ! 608: IN PVOID SynchronizeContext ! 609: ); ! 610: ! 611: VOID ! 612: ParPollingDpcRoutine( ! 613: IN PKDPC Dpc, ! 614: IN PVOID DeferredContext, ! 615: IN PVOID SystemContext1, ! 616: IN PVOID SystemContext2 ! 617: ); ! 618: ! 619: BOOLEAN ! 620: ParPolling( ! 621: IN PVOID Context ! 622: ); ! 623: ! 624: VOID ! 625: ParLogError( ! 626: IN PDRIVER_OBJECT DriverObject, ! 627: IN PDEVICE_OBJECT DeviceObject OPTIONAL, ! 628: IN PHYSICAL_ADDRESS P1, ! 629: IN PHYSICAL_ADDRESS P2, ! 630: IN ULONG SequenceNumber, ! 631: IN UCHAR MajorFunctionCode, ! 632: IN UCHAR RetryCount, ! 633: IN ULONG UniqueErrorValue, ! 634: IN NTSTATUS FinalStatus, ! 635: IN NTSTATUS SpecificIOStatus ! 636: ); ! 637: ! 638: VOID ! 639: ParStartBusyTimer( ! 640: IN PKDPC Dpc, ! 641: IN PVOID DeferredContext, ! 642: IN PVOID SystemContext1, ! 643: IN PVOID SystemContext2 ! 644: ); ! 645: ! 646: VOID ! 647: ParBusyTimer( ! 648: IN PKDPC Dpc, ! 649: IN PVOID DeferredContext, ! 650: IN PVOID SystemContext1, ! 651: IN PVOID SystemContext2 ! 652: ); ! 653: ! 654: BOOLEAN ! 655: ParBusyCallIsr( ! 656: IN PVOID Context ! 657: ); ! 658:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.