summaryrefslogtreecommitdiff
path: root/pyparallel/parallel/parallelppdev.py
diff options
context:
space:
mode:
Diffstat (limited to 'pyparallel/parallel/parallelppdev.py')
-rw-r--r--pyparallel/parallel/parallelppdev.py573
1 files changed, 0 insertions, 573 deletions
diff --git a/pyparallel/parallel/parallelppdev.py b/pyparallel/parallel/parallelppdev.py
deleted file mode 100644
index fc87e90..0000000
--- a/pyparallel/parallel/parallelppdev.py
+++ /dev/null
@@ -1,573 +0,0 @@
-#!/usr/bin/env python
-# parallel port access using the ppdev driver
-
-import struct
-import fcntl
-import os
-
-#----
-# Generated by h2py 0.1.1 from <linux/ppdev.h>,
-# then cleaned up a bit by Michael P. Ashton and then a gain by chris ;-)
-
-def sizeof(type): return struct.calcsize(type)
-def _IOC(dir, type, nr, size): return (dir << _IOC_DIRSHIFT ) | (type << _IOC_TYPESHIFT ) |\
- (nr << _IOC_NRSHIFT ) | (size << _IOC_SIZESHIFT)
-def _IO(type, nr): return _IOC(_IOC_NONE, type, nr, 0)
-def _IOR(type,nr,size): return _IOC(_IOC_READ, type, nr, sizeof(size))
-def _IOW(type,nr,size): return _IOC(_IOC_WRITE, type, nr, sizeof(size))
-
-_IOC_SIZEBITS = 14
-_IOC_SIZEMASK = (1 << _IOC_SIZEBITS ) - 1
-_IOC_NRSHIFT = 0
-_IOC_NRBITS = 8
-_IOC_TYPESHIFT = _IOC_NRSHIFT + _IOC_NRBITS
-_IOC_TYPEBITS = 8
-_IOC_SIZESHIFT = _IOC_TYPESHIFT + _IOC_TYPEBITS
-IOCSIZE_MASK = _IOC_SIZEMASK << _IOC_SIZESHIFT
-IOCSIZE_SHIFT = _IOC_SIZESHIFT
-_IOC_WRITE = 1
-_IOC_DIRSHIFT = _IOC_SIZESHIFT + _IOC_SIZEBITS
-IOC_IN = _IOC_WRITE << _IOC_DIRSHIFT
-_IOC_READ = 2
-IOC_INOUT = (_IOC_WRITE | _IOC_READ) << _IOC_DIRSHIFT
-IOC_OUT = _IOC_READ << _IOC_DIRSHIFT
-
-_IOC_NONE = 0
-PP_IOCTL = ord('p')
-PPCLAIM = _IO(PP_IOCTL, 0x8b)
-PPCLRIRQ = _IOR(PP_IOCTL, 0x93, 'i')
-
-PPDATADIR = _IOW(PP_IOCTL, 0x90, 'i')
-PPEXCL = _IO(PP_IOCTL, 0x8f)
-PPFCONTROL = _IOW(PP_IOCTL, 0x8e, 'BB')
-PPGETFLAGS = _IOR(PP_IOCTL, 0x9a, 'i')
-PPGETMODE = _IOR(PP_IOCTL, 0x98, 'i')
-PPGETMODES = _IOR(PP_IOCTL, 0x97, 'I')
-PPGETPHASE = _IOR(PP_IOCTL, 0x99, 'i')
-PPGETTIME = _IOR(PP_IOCTL, 0x95, 'll')
-PPNEGOT = _IOW(PP_IOCTL, 0x91, 'i')
-PPRCONTROL = _IOR(PP_IOCTL, 0x83, 'B')
-PPRDATA = _IOR(PP_IOCTL, 0x85, 'B')
-#'OBSOLETE__IOR' undefined in 'PPRECONTROL'
-PPRELEASE = _IO(PP_IOCTL, 0x8c)
-#'OBSOLETE__IOR' undefined in 'PPRFIFO'
-PPRSTATUS = _IOR(PP_IOCTL, 0x81, 'B')
-PPSETFLAGS = _IOW(PP_IOCTL, 0x9b, 'i')
-PPSETMODE = _IOW(PP_IOCTL, 0x80, 'i')
-PPSETPHASE = _IOW(PP_IOCTL, 0x94, 'i')
-PPSETTIME = _IOW(PP_IOCTL, 0x96, 'll')
-PPWCONTROL = _IOW(PP_IOCTL, 0x84, 'B')
-PPWCTLONIRQ = _IOW(PP_IOCTL, 0x92, 'B')
-PPWDATA = _IOW(PP_IOCTL, 0x86, 'B')
-#'OBSOLETE__IOW' undefined in 'PPWECONTROL'
-#'OBSOLETE__IOW' undefined in 'PPWFIFO'
-#'OBSOLETE__IOW' undefined in 'PPWSTATUS'
-PPYIELD = _IO(PP_IOCTL, 0x8d)
-PP_FASTREAD = 1 << 3
-PP_FASTWRITE = 1 << 2
-PP_W91284PIC = 1 << 4
-PP_FLAGMASK = PP_FASTWRITE | PP_FASTREAD | PP_W91284PIC
-PP_MAJOR = 99
-_ASMI386_IOCTL_H= None
-_IOC_DIRBITS = 2
-_IOC_DIRMASK = (1 << _IOC_DIRBITS) - 1
-_IOC_NRMASK = (1 << _IOC_NRBITS) - 1
-_IOC_TYPEMASK = (1 << _IOC_TYPEBITS ) - 1
-
-def _IOC_DIR(nr): return (nr >> _IOC_DIRSHIFT) & _IOC_DIRMASK
-def _IOC_NR(nr): return (nr >> _IOC_NRSHIFT) & _IOC_NRMASK
-def _IOC_SIZE(nr): return (nr >> _IOC_SIZESHIFT) & _IOC_SIZEMASK
-def _IOC_TYPE(nr): return (nr >> _IOC_TYPESHIFT) & _IOC_TYPEMASK
-def _IOWR(type, nr, size): return _IOC(_IOC_READ | _IOC_WRITE, type, nr , sizeof(size))
-
-__ELF__ = 1
-__i386 = 1
-__i386__ = 1
-__linux = 1
-__linux__ = 1
-__unix = 1
-__unix__ = 1
-i386 = 1
-linux = 1
-unix = 1
-
-#-------- Constants from <linux/parport.h>
-
-PARPORT_CONTROL_STROBE = 0x1
-PARPORT_CONTROL_AUTOFD = 0x2
-PARPORT_CONTROL_INIT = 0x4
-PARPORT_CONTROL_SELECT = 0x8
-PARPORT_STATUS_ERROR = 8
-PARPORT_STATUS_SELECT = 0x10
-PARPORT_STATUS_PAPEROUT = 0x20
-PARPORT_STATUS_ACK = 0x40
-PARPORT_STATUS_BUSY = 0x80
-
-IEEE1284_MODE_NIBBLE = 0
-IEEE1284_MODE_BYTE = 1
-IEEE1284_MODE_COMPAT = 1<<8
-IEEE1284_MODE_BECP = 1<<9
-IEEE1284_MODE_ECP = 1<<4
-IEEE1284_MODE_ECPRLE = IEEE1284_MODE_ECP | (1<<5)
-IEEE1284_MODE_ECPSWE = 1<<10
-IEEE1284_MODE_EPP = 1<<6
-IEEE1284_MODE_EPPSL = 1<<11
-IEEE1284_MODE_EPPSWE = 1<<12
-IEEE1284_DEVICEID = 1<<2
-IEEE1284_EXT_LINK = 1<<14
-
-IEEE1284_ADDR = 1<<13
-IEEE1284_DATA = 0
-
-PARPORT_EPP_FAST = 1
-PARPORT_W91284PIC = 2
-#----
-
-class Parallel:
- """Class for controlling the pins on a parallel port
-
- This class provides bit-level access to the pins on a PC parallel
- port. It is primarily designed for programs which must control
- special circuitry - most often non-IEEE-1284-compliant devices
- other than printers - using 'bit-banging' techniques.
-
- The current implementation makes ioctl() calls to the Linux ppdev
- driver, using the Python fcntl library. It might be rewritten in
- C for extra speed. This particular implementation is written for
- Linux; all of the upper-level calls can be ported to Windows as
- well.
-
- On Linux, the ppdev device driver, from the Linux 2.4 parallel
- port subsystem, is used to control the parallel port hardware.
- This driver must be made available from a kernel compile. The
- option is called "Support user-space parallel-port drivers". When
- using the module, be sure to unload the lp module first: usually
- the lp module claims exclusive access to the parallel port, and if
- it is loaded, this class will fail to open the parallel port file,
- and throw an exception.
-
- The primary source of information about the Linux 2.4 parallel
- port subsystem is Tim Waugh's documentation, the source for which
- is available in the kernel tree. This document (called,
- appropriately enough, "The Linux 2.4 Parallel Port Subsystem"),
- thoroughly describes the parallel port drivers and how to use
- them.
-
- This class provides a method for each of the ioctls supported by
- the ppdev module. The ioctl methods are named, in uppercase, the
- same as the ioctls they invoke. The documentation for these
- methods was taken directly from the documentation for their
- corresponding ioctl, and modified only where necessary.
-
- Unless you have special reason to use the Linux ioctls, you should
- use instead the upper-level functions, which are named in
- lowerCase fashion and should be portable between Linux and
- Windows. This way, any code you write for this class will (or
- should) also work with the Windows version of this class.
-
- """
- def __init__(self, port = 0):
- if type(port) == type(""):
- self.device = port
- else:
- self.device = "/dev/parport%d" % port
- self._fd = os.open(self.device, os.O_RDWR)
- self.PPEXCL()
- self.PPCLAIM()
- self.setDataDir(1)
- self.setData(0)
-
- def __del__(self):
- self.PPRELEASE()
- if self._fd is not None:
- os.close(self._fd)
-
- def timevalToFloat(self, timeval):
- t=struct.unpack('ll', timeval)
- return t[0] + (t[1]/1000000.0)
-
- def floatToTimeval(self, time):
- sec = int(time)
- usec = int(time*1000000.0)
- return struct.pack('ll', sec, usec)
-
- def PPCLAIM(self):
- """
- Claims access to the port. As a user-land device driver
- writer, you will need to do this before you are able to
- actually change the state of the parallel port in any
- way. Note that some operations only affect the ppdev driver
- and not the port, such as PPSETMODE; they can be performed
- while access to the port is not claimed.
- """
- fcntl.ioctl(self._fd, PPCLAIM)
-
- def PPEXCL(self):
- """
- Instructs the kernel driver to forbid any sharing of the port
- with other drivers, i.e. it requests exclusivity. The PPEXCL
- command is only valid when the port is not already claimed for
- use, and it may mean that the next PPCLAIM ioctl will fail:
- some other driver may already have registered itself on that
- port.
-
- Most device drivers don't need exclusive access to the
- port. It's only provided in case it is really needed, for
- example for devices where access to the port is required for
- extensive periods of time (many seconds).
-
- Note that the PPEXCL ioctl doesn't actually claim the port
- there and then---action is deferred until the PPCLAIM ioctl is
- performed.
- """
- fcntl.ioctl(self._fd, PPEXCL)
-
- def PPRELEASE(self):
- """
- Releases the port. Releasing the port undoes the effect of
- claiming the port. It allows other device drivers to talk to
- their devices (assuming that there are any).
- """
- fcntl.ioctl(self._fd, PPRELEASE)
-
- def PPYIELD(self):
- """
- Yields the port to another driver. This ioctl is a kind of
- short-hand for releasing the port and immediately reclaiming
- it. It gives other drivers a chance to talk to their devices,
- but afterwards claims the port back. An example of using this
- would be in a user-land printer driver: once a few characters
- have been written we could give the port to another device
- driver for a while, but if we still have characters to send to
- the printer we would want the port back as soon as possible.
-
- It is important not to claim the parallel port for too long,
- as other device drivers will have no time to service their
- devices. If your device does not allow for parallel port
- sharing at all, it is better to claim the parallel port
- exclusively (see PPEXCL).
- """
- fcntl.ioctl(self._fd, PPYIELD)
-
- def PPNEGOT(self, mode):
- """
- Performs IEEE 1284 negotiation into a particular
- mode. Briefly, negotiation is the method by which the host and
- the peripheral decide on a protocol to use when transferring
- data.
-
- An IEEE 1284 compliant device will start out in compatibility
- mode, and then the host can negotiate to another mode (such as
- ECP).
-
- The 'mode' parameter should be one of the following constants
- from PPDEV:
-
- - IEEE1284_MODE_COMPAT
- - IEEE1284_MODE_NIBBLE
- - IEEE1284_MODE_BYTE
- - IEEE1284_MODE_EPP
- - IEEE1284_MODE_ECP
-
- The PPNEGOT ioctl actually does two things: it performs the
- on-the-wire negotiation, and it sets the behaviour of
- subsequent read/write calls so that they use that mode (but
- see PPSETMODE).
- """
- fcntl.ioctl(self._fd, PPNEGOT, struct.pack('i', mode))
-
- def PPSETMODE(self, mode):
- """
- Sets which IEEE 1284 protocol to use for the read and write
- calls.
-
- The 'mode' parameter should be one of the following constants
- from PPDEV:
-
- - IEEE1284_MODE_COMPAT
- - IEEE1284_MODE_NIBBLE
- - IEEE1284_MODE_BYTE
- - IEEE1284_MODE_EPP
- - IEEE1284_MODE_ECP
- """
- fcntl.ioctl(self._fd, PPSETMODE, struct.pack('i', mode))
-
- def PPGETMODE(self):
- """
- Retrieves the IEEE 1284 mode being used for read and
- write. The return value is one of the following constants
- from PPDEV:
-
- - IEEE1284_MODE_COMPAT
- - IEEE1284_MODE_NIBBLE
- - IEEE1284_MODE_BYTE
- - IEEE1284_MODE_EPP
- - IEEE1284_MODE_ECP
- """
- ret = struct.pack('i', 0)
- ret = fcntl.ioctl(self._fd, PPGETMODE, ret)
- return struct.unpack('i', ret)[0]
-
- def PPGETTIME(self):
- """
- Retrieves the time-out value. The read and write calls will
- time out if the peripheral doesn't respond quickly enough. The
- PPGETTIME ioctl retrieves the length of time that the
- peripheral is allowed to have before giving up.
-
- Returns the timeout value in seconds as a floating-point value.
- """
- ret = struct.pack('ll', 0, 0)
- ret = fcntl.ioctl(self._fd, PPGETTIME, ret)
- return timevalToFloat(ret)
-
- def PPSETTIME(self, time):
- """
- Sets the time-out (see PPGETTIME for more information).
- 'time' is the new time-out in seconds; floating-point values
- are acceptable.
- """
- fcntl.ioctl(self._fd, PPSETTIME, floatToTimeval(time))
-
- def PPGETMODES(self):
- """
- Retrieves the capabilities of the hardware (i.e. the modes
- field of the parport structure).
- """
- raise NotImplementedError
-
- def PPSETFLAGS(self):
- """
- Sets flags on the ppdev device which can affect future I/O
- operations. Available flags are:
-
- - PP_FASTWRITE
- - PP_FASTREAD
- - PP_W91284PIC
- """
- raise NotImplementedError
-
- def PPWCONTROL(self, lines):
- """
- Sets the control lines. The 'lines' parameter is a bitwise OR
- of the following constants from PPDEV:
-
- - PARPORT_CONTROL_STROBE
- - PARPORT_CONTROL_AUTOFD
- - PARPORT_CONTROL_INIT
- - PARPORT_CONTROL_SELECT
- """
- fcntl.ioctl(self._fd, PPWCONTROL, struct.pack('B', lines))
-
- def PPRCONTROL(self):
- """
- Returns the last value written to the control register, in the
- form of an integer, for which each bit corresponds to a control
- line (although some are unused).
-
- This doesn't actually touch the hardware; the last value
- written is remembered in software. This is because some
- parallel port hardware does not offer read access to the
- control register.
-
- The control lines bits are defined by the following constants
- from PPDEV:
-
- - PARPORT_CONTROL_STROBE
- - PARPORT_CONTROL_AUTOFD
- - PARPORT_CONTROL_SELECT
- - PARPORT_CONTROL_INIT
- """
- ret = struct.pack('B',0)
- ret = fcntl.ioctl(self._fd, PPRCONTROL, ret)
- return struct.unpack('B', ret)[0]
-
- def PPFCONTROL(self, mask, val):
- """
- Frobs the control lines. Since a common operation is to change
- one of the control signals while leaving the others alone, it
- would be quite inefficient for the user-land driver to have to
- use PPRCONTROL, make the change, and then use PPWCONTROL. Of
- course, each driver could remember what state the control
- lines are supposed to be in (they are never changed by
- anything else), but in order to provide PPRCONTROL, ppdev must
- remember the state of the control lines anyway.
-
- The PPFCONTROL ioctl is for "frobbing" control lines, and is
- like PPWCONTROL but acts on a restricted set of control
- lines. The ioctl parameter is a pointer to a struct
- ppdev_frob_struct:
-
- struct ppdev_frob_struct {
- unsigned char mask;
- unsigned char val;
- };
-
- The mask and val fields are bitwise ORs of control line names
- (such as in PPWCONTROL). The operation performed by PPFCONTROL
- is:
-
- new_ctr = (old_ctr & ~mask) | val
-
- In other words, the signals named in mask are set to the
- values in val.
- """
- fcntl.ioctl(self._fd, PPFCONTROL, struct.pack('BB', mask, val))
-
- def PPRSTATUS(self):
- """
- Returns an unsigned char containing bits set for each status
- line that is set (for instance, PARPORT_STATUS_BUSY). The
- ioctl parameter should be a pointer to an unsigned char.
- """
- ret = struct.pack('B',0)
- ret = fcntl.ioctl(self._fd, PPRSTATUS, ret)
- return struct.unpack('B', ret)[0]
-
- def PPDATADIR(self, out):
- """
- Controls the data line drivers. Normally the computer's
- parallel port will drive the data lines, but for byte-wide
- transfers from the peripheral to the host it is useful to turn
- off those drivers and let the peripheral drive the
- signals. (If the drivers on the computer's parallel port are
- left on when this happens, the port might be damaged.)
- This is only needed in conjunction with PPWDATA or PPRDATA.
-
- The 'out' parameter indicates the desired port direction. If
- 'out' is true or non-zero, the drivers are turned on (forward
- direction); otherwise, the drivers are turned off (reverse
- direction).
- """
- if out:
- msg=struct.pack('i',0)
- else:
- msg=struct.pack('i',1)
- fcntl.ioctl(self._fd, PPDATADIR, msg)
-
- def PPWDATA(self, byte):
- """
- Sets the data lines (if in forward mode). The ioctl parameter
- is a pointer to an unsigned char.
- """
- fcntl.ioctl(self._fd, PPWDATA,struct.pack('B',byte))
-
- def PPRDATA(self):
- """
- Reads the data lines (if in reverse mode). The ioctl parameter
- is a pointer to an unsigned char.
- """
- ret=struct.pack('B',0)
- ret=fcntl.ioctl(self._fd, PPRDATA,ret)
- return struct.unpack('B',ret)[0]
-
- def PPCLRIRQ(self):
- """
- Returns the current interrupt count, and clears it. The ppdev
- driver keeps a count of interrupts as they are triggered.
- """
- ret=struct.pack('i',0)
- ret=fcntl.ioctl(self._fd, PPCLRIRQ,ret)
- return struct.unpack('i',ret)[0]
-
- def PPWCTLONIRQ(self, lines):
- """
- Set a trigger response. Afterwards when an interrupt is
- triggered, the interrupt handler will set the control lines as
- requested. The ioctl parameter is a pointer to an unsigned
- char, which is interpreted in the same way as for PPWCONTROL.
-
- The reason for this ioctl is simply speed. Without this ioctl,
- responding to an interrupt would start in the interrupt
- handler, switch context to the user-land driver via poll or
- select, and then switch context back to the kernel in order to
- handle PPWCONTROL. Doing the whole lot in the interrupt
- handler is a lot faster.
- """
- fcntl.ioctl(self._fd, PPWCTLONIRQ,struct.pack('B',lines))
-
- #data lines
-## def data(self):
-## """Returns the states of the data bus line drivers (pins 2-9)"""
-## return self._data
-
- def setDataDir(self,out):
- """Activates or deactivates the data bus line drivers (pins 2-9)"""
- self._dataDir = out
- self.PPDATADIR(out)
-
- def dataDir(self):
- """Returns true if the data bus line drivers are on (pins 2-9)"""
- return self._dataDir
-
- #control lines
-## def strobe(self):
-## """Returns the state of the nStrobe output (pin 1)"""
-## return (self.PPRCONTROL()&PARPORT_CONTROL_STROBE)==0
-
- def setDataStrobe(self, level):
- """Sets the state of the nStrobe output (pin 1)"""
- if level:
- self.PPFCONTROL(PARPORT_CONTROL_STROBE, 0)
- else:
- self.PPFCONTROL(PARPORT_CONTROL_STROBE, PARPORT_CONTROL_STROBE)
-
-## def autoFd(self):
-## """Returns the state of the nAutoFd output (pin 14)"""
-## return (self.PPRCONTROL()&PARPORT_CONTROL_AUTOFD)==0
-
- def setAutoFeed(self, level):
- """Sets the state of the nAutoFd output (pin 14)"""
- if level:
- self.PPFCONTROL(PARPORT_CONTROL_AUTOFD, 0)
- else:
- self.PPFCONTROL(PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD)
-
-## def init(self):
-## """Returns the state of the nInit output (pin 16)"""
-## return (self.PPRCONTROL()&PARPORT_CONTROL_INIT)!=0
-
- def setInitOut(self, level):
- """Sets the state of the nInit output (pin 16)"""
- if level:
- self.PPFCONTROL(PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT)
- else:
- self.PPFCONTROL(PARPORT_CONTROL_INIT, 0)
-
-## def selectIn(self):
-## """Returns the state of the nSelectIn output (pin 17)"""
-## return (self.PPRCONTROL()&PARPORT_CONTROL_SELECT)==0
-
- def setSelect(self,level):
- """Sets the state of the nSelectIn output (pin 17)"""
- if level:
- self.PPFCONTROL(PARPORT_CONTROL_SELECT, 0)
- else:
- self.PPFCONTROL(PARPORT_CONTROL_SELECT, PARPORT_CONTROL_SELECT)
-
- def setData(self,d):
- """Sets the states of the data bus line drivers (pins 2-9)"""
- self._data=d
- return self.PPWDATA(d)
-
- #status lines
- def getInError(self):
- """Returns the level on the nFault pin (15)"""
- return (self.PPRSTATUS() & PARPORT_STATUS_ERROR) != 0
-
- def getInSelected(self):
- """Returns the level on the Select pin (13)"""
- return (self.PPRSTATUS() & PARPORT_STATUS_SELECT) != 0
-
- def getInPaperOut(self):
- """Returns the level on the paperOut pin (12)"""
- return (self.PPRSTATUS() & PARPORT_STATUS_PAPEROUT) != 0
-
- def getInAcknowledge(self):
- """Returns the level on the nAck pin (10)"""
- return (self.PPRSTATUS() & PARPORT_STATUS_ACK) != 0
-
- def getInBusy(self):
- """Returns the level on the Busy pin (11)"""
- return (self.PPRSTATUS() & PARPORT_STATUS_BUSY) == 0
-