Abstract:
A system and method for providing multiple modes of parallel communications between a host and a peripheral. In the system and method, a driver provides support for a plurality of transfer modes while satisfying the streams requirements of a host kernel during both forward and reverse transfers. The driver begins in a known mode and negotiates the host and peripheral into a best mode supported by both the host and the peripheral. The driver satisfies streams requirements, thereby permitting high level handshaking and use of ioct1s in UNIX based systems. When data is to be transferred, a message is placed on a queue to be serviced in the order received. The type of the message is indicative of the direction of the desired transfer. Each message is serviced in turn, and the transfer conducted using the most efficient mode available.

Description:
BACKGROUND OF THE INVENTION 
     (1) Field of the Invention 
     The invention relates to parallel port device drivers. More specifically, the invention relates to the device driver which can be used to implement the IEEE 1284 bi-directional parallel peripheral interface standard. 
     (2) Related Art 
     Parallel port communications have been generally well-known for some time. Throughout the 1980&#39;s, a unidirectional parallel communication between hosts and printers or hosts and other peripheral devices was commonly used. This unidirectional mode of communication became known as Centronics® communications after the company which first introduced it, Centronics Data Computer Corporation. Centronics® is an 8 bit parallel unidirectional communication link between the host and a peripheral with data only flowing in a forward direction, i.e. from the host to the peripheral. Centronics® was so widely used, it became a de facto standard in the industry. Unfortunately, Centronics® suffers from one major shortcoming which limits its utility in a network environment, specifically, it is unidirectional It is also relatively slow. 
     Accordingly, as networks have become more prevalent, there has been a push in the industry to develop a standard method for bi-directional parallel communications between hosts and peripheral devices. In response to this push, IEEE has promulgated a standard signaling method for a bi-directional parallel peripheral interface for personal computers, IEEE 1284 specification (&#34;1284&#34;). The 1284 defines a signaling method for bi-directional parallel communications between hosts and peripheral devices. It is also asynchronous and fully interlocked. By virtue of the fact that there were a number of divergent interests in the working group preparing the standard, the standard defines five distinct modes of operation. Specifically, compatibility mode, nibble mode, byte mode, enhanced parallel port mode (EPP mode) and extended capabilities port mode (ECP mode) are all defined under the umbrella of a &#34;single&#34; standard. 
     Compatibility mode is basically the former Centronics® mode, which provides an asynchronous byte-wide forward (host to peripheral) channel with data and status lines used according to the prior definitions. Compatibility mode has the effect of making 1284 backward compatible. 
     Nibble mode is a peripheral to host unidirectional protocol which can be used in conjunction with compatibility mode for a full bi-directional interface. Data is transferred to the host four bits at a time over four control signals defined in the Centronics® parallel port. The nibble protocol employs a program input/output (PIO) interface to work with existing parallel port controllers. The data transfer rate is quite slow. 
     Byte mode is a peripheral to host unidirectional protocol which can be used in conjunction with compatibility mode for a full bi-directional interface. Bytes are transferred to the host over the eight data lines. Byte mode is twice as fast as nibble mode, but is still a PIO interface and, consequently, relatively slow. Moreover, the byte mode protocol required an expanded definition of the data lines from the existing Centronics® standard. 
     Expanded parallel port mode defines a bi-directional protocol in which bytes are transferred in either direction by an interrupt driven PIO interface. Either the host or the peripheral may fill a 4 byte buffer and await a signal to indicate the transfer was completed. While this mode is faster than byte or nibble mode, it is still an interrupt driven PIO which is relatively slow and has not gained wide acceptance. 
     Extended compatibility port mode is a high speed bi-directional protocol in which bytes are transferred in either direction by a DMA driven interface. This mode is the fastest and most efficient of the IEEE 1284 modes. 
     While the electrical signaling and cabling requirements for each mode are well-defined in the IEEE 1284 specification, and chip manufacturers have provided the hardware necessary to implement these various modes, the issue of 1284 device drivers has been largely ignored. Significantly, each mode defines a separate and distinct protocol with different signaling and phase requirements which would arguably justify implementing each protocol as a separate driver. However, because any single device must have only a single driver, the 1284 specification creates a unique problem of requiring the implementation of multiple distinct protocols within the single driver. This is particularly true given that the specification requires that to be 1284 compliant, a device must support at least compatibility mode and nibble mode. 
     A portion of the host kernel is the streams environment. The streams environment has many special requirements which are detailed in full in the Streams Programmer&#39;s Guide Sun OS 5.3 (1993). Particularly in the context of a 1284 device driver, a streams interface allows handshaking with upper level modules to provide effective coordination of data transfers. Additionally, the streams environment provides required support for ioctls making such ioctls available for use with the driver. 
     Therefore, it would be desirable to develop a device driver which is 1284 compliant and readily interfaces with the streams environment. 
     BRIEF SUMMARY OF THE INVENTION 
     A system and method for providing multiple modes of parallel communications between a host and a peripheral is disclosed. In the system and method, a driver provides support for a plurality of transfer modes while satisfying the steams requirements of a host kernel during both forward and reverse transfers. The driver begins in a known mode and negotiates the host and peripheral into a best mode supported by both the host and the peripheral. The driver satisfies streams requirements, thereby permitting high level handshaking and use of ioctls in UNIX based systems. When data is to be transferred, a message is placed on a queue to be serviced in the order received. The type of the message is indicative of the direction of the desired transfer. Each message is serviced in turn, and the transfer conducted using the most efficient mode available. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a block diagram of a system using one embodiment of the invention. 
     FIGS. 2a-d are flowcharts of operation of the parallel port driver of one embodiment of the invention. 
     FIG. 3a is a code diagram of an entry point for the driver of one embodiment of the invention. 
     FIG. 3b is a code diagram of the streams setup routine in the entry point of FIG. 3a. 
     FIG. 4 is a code diagram of a negotiation routine for the driver of one embodiment of the invention. 
     FIG. 5 is a code diagram of a write-side entry point for the driver of one embodiment of the invention. 
     FIG. 6 is a code diagram of a write-side service routine for the driver of one embodiment of the invention. 
     FIGS. 7a-c are code diagrams of a DMA transfer initiation routine for the driver of one embodiment of the invention. 
     FIGS. 8a-d are code diagrams of interrupt investigation and service routine of the driver of one embodiment of the invention. 
     FIGS. 9a-c are code diagrams of a backchannel transfer routine for the driver of one embodiment of the invention. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     A method and system for providing multiple modes of parallel communications between a host and a peripheral device is disclosed. In one embodiment, the system is 1284 compliant. In the following description, for the purposes of explanation, specific applications, numbers, and configurations are set forth in order to supply a full understanding of the present invention. However, it would be apparent to one skilled in the art that the present invention may be practiced without the specific details. In other instances, well-known systems are shown in diagrammatical or block diagram form in order not to obscure the present invention unnecessarily. 
     FIG. 1 shows a block diagram of a system employing the instant invention. A user 1 communicates with the host kernel 2 by a standard user interface 9. The kernel 2 supports the streams environment 3. The 1284 specification 5 is implemented partially by hardware 6 and partially by the ecpp driver 4 of the invention. The ecpp driver also interfaces with the streams environment 3 to achieve the streams compatible 1284 compliant device driver. The portion of the 1284 specification 5 implemented by hardware 6 is dictated by the 1284 specification and supplied by external vendors. Similarly, cabling 8 which interfaces between the kernel 2 and the peripheral 7, is also dictated by the 1284 specification and is commercially available. Peripheral 7 can be any peripheral, including printers, scanners, etc. 
     FIGS. 2a-d are flowcharts of the operation of the ecpp driver of the invention. The ecpp driver has four major entry points. User application programs may access two of these: ecpp --  open() routine and the ecpp --  wput() routine. In addition to these entry points, the ecpp driver is composed of two other major entry points: ecpp --  wrsv() and ecpp --  isr(). The ecpp --  wrsv() routine is responsible for invoking the hardware to actually transfer the data. This routine is invoked by the UNIX kernel. The ecpp --  isr() routine is an interrupt routine that is invoked by the hardware when it requires special attention. 
     FIG. 2a is a flowchart of the ecpp --  open() routine. The ecpp --  open() routine is responsible for initializing the driver and associated hardware. Functional block 200 corresponds to opening the driver through an entry point ecpp --  open(). Functional block 201 corresponds to configuring the host and peripheral into a particular start mode with well-defined characteristics. The start mode in this case is compatibility mode. These functions are all performed by the ecpp --  open() routine described in detail below. 
     Once the host and peripheral are set to compatibility mode, the driver sets default values for its state variables at fictional block 202. Afterwards, the driver negotiates the host and peripheral into the best mode supported by both devices at functional block 203. It is anticipated that ECP mode is the best mode and, therefore, the system will first attempt to negotiate into ECP mode. If the system is unable to negotiate into ECP mode, it will then attempt to negotiate into nibble mode. If it fails to negotiate into nibble mode, it will default back into compatability mode. Upon the completion of negotiation at functional block 204, the driver will conduct the necessary structure allocation and structure initialization to conform to the streams structure on the kernel. This enables the put and service routines for reading and writing to or from the read and write queues so that data can be transferred between the host and peripheral from or to the respective queue. Additionally, the put and service routines handle streams requirements corresponding to handshaking with upper level modules and ioctl support. Upon completion, the driver is ready to conduct I/O with the peripheral device. The entry point ecpp --  open() is terminated. 
     FIG. 2b is a flowchart of the ecpp --  wput() routine. The ecpp --  wput() routine is responsible for sending messages that request the kernel and driver to transfer data. If the user application has data to transfer to the peripheral device, or awaits for data to be sent from the peripheral device, the application will send a data buffer to the driver at functional block 206. The driver will queue all requests for later processing at functional block 207. At this point, the write put routine will exit. 
     FIG. 2c is a flowchart of the ecpp --  wsrv routine. The streams facility in the UNIX kernel will invoke the write service routine ecpp --  wsrv(), when it believes data is in the write queue of the driver. Decision block 205 corresponds to a determination by the write service routine itself, of whether a message is on the write queue. If the write queue is empty, the routine terminates. Otherwise, it continues processing the message. Messages on the write queue correspond to either forward transfers or a request for a reverse transfer. Accordingly, decision block 206 corresponds to determining if the message on the write queue indicates a reverse transfer has been requested. If it does, steams requirements are satisfied in functional block 207, and a reverse transfer is initiated in functional block 208. Registers are programmed for PIO in functional block 209, and the reverse channel data is transferred through a PIO interface. It is determined whether the read queue is empty at decision box 210. If the read queue is not empty, the register stack is again programmed for PIO. If the read queue is empty, the write queue is again checked to determine if additional transfers are waiting, at decision block 205. 
     If the message on the write queue does not indicate a reverse transfer has been requested, the message is a forward transfer headed for a peripheral. Functional block 213 corresponds to the satisfaction of streams requirements by the ecpp --  put() and/or ecpp --  wsrv() routine after which the forward transfer is initiated at functional block 214 by a call to ecpp --  start(). The system proceeds to check the write queue of additional pending messages. 
     FIG. 2d is a flowchart of the ecpp --  isr routine. If the hardware requests attention, the interrupt service routine for the parallel port ecpp --  isr() will be invoked. In decision block 220, the routine determines if the interrupt was invoked because an error condition occurred. If it did, functional block 221 represents the handling of the error condition. If the interrupt was not caused from an error condition, the routine determines, at decision block 222, if the interrupt was caused because the hardware indicates that the current DMA transfer has completed. If it is, the handling of the DMA completion is represented by functional block 223. If the interrupt was not cause for either of these two reasons, the routine determines at decision block 224 if the interrupt was caused because the peripheral is requesting to send data. The handling of the backchannel request is performed in functional block 225. After the appropriate processing, the interrupt routine exits. 
     FIG. 3a is a code diagram of an entry point for opening one embodiment of the ecpp device driver of the invention. The ecpp driver is opened using a conventional open driver entry point ecpp --  open(). When the open routine is called, the driver attempts to acquire a device mutex for a peripheral device to or from which a parallel port transfer is desired. If the driver acquires the mutex, and if the driver has not been previously open, the driver marks the open flag as TRUE and then releases the mutex. 
     After the driver completes this initial step, the routine initializes a set of state variables as shown in FIG. 3a. The state variables include the current --  mode, current --  phase and port type of the driver. Following this, ecpp --  open() initializes the parallel port IC registers to its default settings which represents compatibility mode. Afterwards, ecpp --  default --  negotiation() is invoked. 
     FIG. 4 shows the algorithm for ecpp --  default --  negotiation(). The ecpp driver of this embodiment is defined to support ECP mode, nibble mode and compatibility mode. Since ECP mode is the most efficient mode, the driver first attempts to negotiate the host and peripheral into ECP mode. If the negotiation is not successful, an attempt to negotiate into nibble mode is made. If negotiation into nibble mode also fails, the driver defaults into compatibility mode. In this mode, the driver can only transfer data from the host to the peripheral device. The peripheral to host data channel, referred to as the backchannel, is inactive in compatibility mode. Once ecpp --  default --  negotiation() is completed, ecpp --  open() checks that all parallel port IC registers and corresponding state variables are at the appropriate settings. 
     FIG. 3b is a code diagram of the initialization of streams structures and values in an embodiment of the ecpp device driver. This initialization is part of the ecpp --  open() routine of FIG. 3a. Once the driver returns from the default negotiation and the state variable are confirmed correct, ecpp --  open() initializes the streams structures and values to ensure driver compatibility with the streams environment. Upon completing this task, ecpp --  open() returns. 
     FIG. 5 is a code diagram of an entry point, ecpp --  wput(), for write-side data transfers through the driver for one embodiment of the invention. The definition of this routine is essential to comply with the streams requirements of the operating system. All messages posted to this routine are processed according to their type. The most significant type of message block type is M --  DATA. This type of message block represents data that is to be transferred to the peripheral device. If an M --  DATA message block is received, ecpp --  wput() checks to see if it can put the message block on a write queue. If it can, it does so and the routine terminates. If it can not, an error is indicated and the routine terminates. 
     FIG. 6 is a code diagram of a write-side service routine, ecpp --  wsrv( ), for the driver of one embodiment of the invention. This routine fulfills the asynchronous write-side streams transfer routine requirements. This routine also processes messages according to the message type. Data of M --  DATA type are message blocks that are being transferred from the host to tee peripheral device. M --  CTL messages indicate data is being transferred from the peripheral device to the host computer. 
     The routine ecpp --  wsrv() collects M --  DATA message block data and stores this data in a temporary buffer. It continues to collect data in the temporary buffer until its size reaches the DMABUFSZ. Once this has been achieved, the forward transfer is initiated by the ecpp --  start( ) routine. This routine is discussed below in connection with FIGS. 7a-c. 
     If ecpp --  wsrv() receives an M --  CTL message block, it indicates that the peripheral device has data to send to the host computer. The driver negotiates the driver into the appropriate mode, collects data and formats it into the streams structure through the invocation of the ecpp --  peripheral2host() routine. The routine ecpp --  peripheral2host() is discussed below in connection with FIGS. 9a-c. 
     FIGS. 7a-c is a DMA initiation routine of one embodiment of the invention. The basic task of this routine is to initiate the hardware to conduct a DMA transfer from tee main memory of the host computer to a device FIFO. This task is completed in several steps. As shown in FIG. 7a, initially ecpp --  start() gains the appropriate DMA structures and values as required by the operating system. Secondly, the routine sets the parallel port IC into the appropriate phase and sets the current --  phase state variable. This varies depending on the mode of operation. FIGS. 7b and 7c show the setting of phase and the corresponding state variables for nibble mode and ECP mode, respectively. Finally, the routine programs these DMA structures, the DMA commences, and the routine terminates. 
     FIGS. 8a-d are code diagrams for interrupt service in one embodiment of the invention. As shown in FIG. 8a, ecpp --  isr() checks if the device has an interrupt pending flag (DCSR --  INT --  PEND) in the DMAC control status register (dcsr). If this flag is not set, it indicates that the interrupt was not intended for this device. Consequently, the ecpp --  isr() terminates. If the flag is set, the routine determines the reason why the interrupt was invoked for this device. 
     The ecpp --  isr() routine is invoked if a hardware interrupt is generated by the device. Such an interrupt may be invoked for one of three reasons: (1) An error occurs during a DMA transfer; or (2) a DMA transfer completes (TC); or (3) the peripheral requests the backchannel to be read. Essentially, ecpp --  isr() has been coded into three major sections to handle these conditions. 
     In FIG. 8b, ecpp --  isr() first checks to see if an error occurred during a DMA transfer. If an error occurred, the DCSR --  ERR --  PEND bit will be set in the DMAC control register. In this case, the control register is reset, and the DMA resources are freed for other use by the operating system. The interrupt routine returns at this point. 
     If an error condition interrupt has not been generated, ecpp &#39;  isr() checks to see if a transfer complete interrupt has occurred as shown in FIG. 8c. The ecpp --  isr() routine accomplishes this task by checking the DMAC control register. The DCSR --  TC bit will be set in this register if such a condition exists, and the routine disables the DMA mechanism with the DMAC chip. Afterwards, the DMA resources of the operating system are freed, and the routine returns. 
     The third case is shown in FIG. 8d. If the peripheral device requests the backchannel to be read, the ECPP --  nERR bit of the parallel port chip status register (dsr) will be cleared. In such a situation, the ecpp --  isr() routine masks parallel port interrupts, re-enables DMA transfers, and sets the parallel port IC to the appropriate mode. Finally, in such a situation, ecpp --  isr() will create a M --  CTL message block and pass this message block to the write queue. This message block will be processed at a later time by the ecpp --  wsrv() routine. After putting this message block on the queue, ecpp --  isr() will return. 
     FIGS. 9a-c are code diagrams of a backchannel transfer in one embodiment of the invention showing the algorithm for the ecpp --  peripheral2host() routine. This routine is responsible for transferring data from the peripheral to the host. Furthermore, this routine transfers the data under the constraints and formatting convention of the streams interface. The method in which the routine retrieves data from the peripheral depends on which backchannel mode the driver is currently set to. The backchannel mode was set in ecpp --  default --  negotiation() as presented in FIG. 4. If backchannel is set to compatibility mode, reverse transfers are not supported. That is, under the compatibility protocol, data may not be transferred from the peripheral back to the host. Consequently, ecpp --  peripheral2host() immediately returns under such conditions. 
     FIG. 9b shows the nibble mode case. If the backchannel is set to nibble mode, the driver negotiates the parallel port and the peripheral device into nibble mode. Afterwards, ecpp --  peripheral2host() invokes nibble --  peripheral2host() which directly programs the parallel port registers to conduct the 1284 events that will lead the peripheral device to transfer a byte to the host. Once this byte has been retrieved, ecpp --  peripheral2host() will allocate a message block and transfer the retrieved byte to this block. Afterwards, this message block is put onto the read-queue for upstream processing. 
     FIG. 9c shows the ECP mode case. If the backchannel is set to ECP mode, the driver will negotiate the parallel port and peripheral device into reverse ECP phase. Afterwards, ecp --  peripheral2host() will be invoked to actually transfer data from the peripheral to the host under ECP mode. Once the transfer is complete, the routine ends. 
     Through the above-described routines, a 1284 compliant driver supporting compatibility, nibble and ECP modes is created. The invention has been described with reference to a specific embodiment thereof. It will, however, be evident that various modifications and changes can be made thereto without departing from the broader spirit and scope of the invention as set forth in the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. Therefore, the scope of the invention should be limited only by the appended claims.