#include <sys/types.h>

#include <sys/ecppio.h>

ecpp@unit-address

The ecpp driver provides a bi-directional interface to IEEE 1284 compliant devices as well as a forward single-directional interface to Centronics devices. In addition to the Centronics protocol, the ecpp driver supports the IEEE 1284Compatibility, Nibble, and ECP protocols. ECPP_COMPAT_MODE and ECPP_CENTRONICS modes of operation have logically identical handshaking protocols, however devices that support ECPP_COMPAT_MODE are IEEE 1284 compliant devices. IEEE 1284 compliant devices support at least ECPP_COMPAT_MODE and ECPP_NIBBLE_MODE. Centronics devices support only ECPP_CENTRONICS mode.

By default, ECPP_COMPAT_MODE devices have a strobe handshaking pulse width of 500ns. For this mode, forward data transfers are conducted by DMA. By default, the strobe pulse width for ECPP_CENTRONICS devices is two microseconds. Forward transfers for these devices are managed through PIO. The default characteristics for both ECPP_COMPAT_MODE and ECPP_CENTRONICS devices may be changed through tunable variables defined in ecpp.conf.

The ecpp driver is an exclusive-use device, meaning that if the device is already open, subsequent opens fail with EBUSY.

Each time the ecpp device is opened, the device is marked as EBUSY and the configuration variables are set to their default values. The write_timeout period is set to 90 seconds.

The driver sets the mode variable according to the following algorithm: The driver initially attempts to negotiate the link into ECPP_ECP_MODE during open(2). If it fails, the driver tries to negotiate into ECPP_NIBBLE_MODE mode. If that fails, the driver operates in ECPP_CENTRONICS mode. Upon successfully opening the device, IEEE 1284 compliant devices will be left idle in either reverse idle phase of ECPP_ECP_MODE or in ECPP_NIBBLE_MODE. Subsequent calls to write(2) invokes the driver to move the link into either ECPP_COMPAT_MODE or the forward phase of ECPP_ECP_MODE. After the transfer completes, the link returns to idle state.

The application may attempt to negotiate the device into a specific mode or set the write_timeout values through the ECPPIOC_SETPARMS ioctl(2) call. For mode negotiation to be successful, both the host workstation and the peripheral must support the requested mode.

Characteristics of the ecpp driver may be tuned by the variables described in /kernel/drv/ecpp.conf. These variables are read by the kernel during system startup. To tune the variables, edit the ecpp.conf file and invoke update_drv(1M) to have the kernel read the file again.

Some Centronics peripherals and certain IEEE 1284 compatible peripherals will not operate with the parallel port operating in a fast handshaking mode. If printing problems occur, set "fast-centronics" and "fast-1284-compatible" to "false." See /kernel/drv/ecpp.conf for more information.

The ecpp driver is a full duplex STREAMS device driver. While an application is writing to an IEEE 1284 compliant device, another thread may read from it.

A write(2) operation returns the number of bytes successfully written to the stream head. If a failure occurs while a Centronics device is transferring data, the content of the status bits will be captured at the time of the error and can be retrieved by the application program using the BPPIOC_GETERR ioctl(2) call. The captured status information is overwritten each time an attempted transfer or a BPPIOC_TESTIO ioctl(2) occurs.

If a failure or error condition occurs during a read(2), the number of bytes successfully read is returned (short read). When attempting to read a port that has no data currently available, read(2) returns 0 if O_NDELAY is set. If O_NONBLOCK is set, read(2) returns -1 and sets errno to EAGAIN. If O_NDELAY and O_NONBLOCK are clear, read(2) blocks until data become available.

The ioctl(2) calls described below are supported. Note that when ecpp is transferring data, the driver waits until the data has been sent to the device before processing the ioctl(2) call.

The ecpp driver supports prnio(7I) interfaces.

Note -

The following ioctl(2) calls are supported for backward compatibility and are not recommended for new applications: ECPPIOC_GETPARMS

struct ecpp_transfer_parms {
 int write_timeout;
 int mode;
};

struct ecpp_device_id {
 int mode; /* mode to use for reading device id */
 int len; /* length of buffer */
 int rlen; /* actual length of device id string */
 char *addr; /* buffer address */
};

struct bpp_error_status {
 char timeout_occurred; /* 1=timeout */
 char bus_error; /* not used */
 uchar_t pin_status; /* status of pins which
 /* could cause error */
};

The following ioctls are used to directly read and write the parallel port status and control signals. If the current mode of the device is ECPP_ECP_MODE or ECPP_NIBBLE_MODE, the driver negotiates the link into ECPP_COMPAT_MODE, gets or sets the registers and then returns the link to ECPP_NIBBLE_MODE. If the current mode is ECPP_CENTRONICS or ECPP_COMPAT_MODE, these ioctls will get/set the register values in the current mode. ECPPIOC_GETREGS

struct ecpp_regs {
 uchar dsr; /* status reg */
 u_char dcr; /* control reg */
};

See attributes(5) for descriptions of the following attributes:

modload(1M), modunload(1M), update_drv(1M)ioctl(2), open(2), read(2), write(2), attributes(5), bpp(7D), usbprn(7D), prnio(7I), streamio(7I)

IEEE Std 1284-1994

http://www.sun.com/io