---

parport.c

Go to the documentation of this file.

/*
  parport.c

  External interface to parallel port I/O

  Processes need to be root, or run setuid-root, in order to run this,
  even with the call to ioperm().

  Modification history:


  28-Jun-2000 WPS changed %i to %l in sscanf to avoid warning.
  27-Jun-2000 WPS changed asm/io.h to sys/io.h to avoid a bunch of warnings under linux_2_2_14.
  20-Mar-2000 WPS added unused attribute to parport_h to avoid 'defined but not used' compiler warning
  29-Sep-1999  FMP moved #include "rcs_prnt.h" into don't DO_IT section
  21-Sep-1999  WPS eliminate sscanf and printf calls not supported under CE.
  7-Aug-1998  FMP changed extInit/Quit() to extDioInit/Quit()
  5-Aug-1998  FMP added #ifndef RTLINUX around ioperm() call in pptInit(),
  since it's not needed for RT-Linux
  10-Jul-1998  FMP added -addr flag to set io address
  8-Jul-1998  FMP changed PPT_ to PARPORT_ for consistency with INI file
  6-Nov-1997  FMP added pptDioCheck(); removed inversion correction
  29-Oct-1997 FMP fixed bugs, inverted the reverse polarity ones
  24-Oct-1997 FMP created
  */

/* ident tag */
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

static char __attribute__((unused)) ident[] = "$Id: parport.c,v 1.14 2001/10/10 17:35:46 wshackle Exp $";

/* set DO_IT FLAG for really writing, else don't do inb(), outb() */
#ifdef LINUX
#define DO_IT
#else
#if defined(rtlinux) || defined(rtai)
#define DO_IT
#endif
#endif

#ifdef MAIN

#ifndef UNDER_CE
#include <stdio.h>
#endif

#include <stdlib.h>
#include <string.h>

#endif

#include "parport.h"            /* these decls */

/* the IO address of the board; override by setting global before call
   to pptDioInit() */
unsigned long int PARPORT_IO_ADDRESS = DEFAULT_PARPORT_IO_ADDRESS;

#define PARPORT_IO_WIDTH 3              /* number of bytes taken up */

#ifdef DO_IT

/* real parallel port IO */

#if !defined(rtlinux) && !defined(rtai)
#include <unistd.h>             /* ioperm() */
#ifdef DEFINE_EXTERN_BEFORE_IO
#define extern
#endif
#endif

#ifdef __KERNEL__
#include <linux/kernel.h>
#include <linux/fs.h>
#endif

#ifndef LINUX_VERSION_CODE
#include <linux/version.h>
#endif

// Pre 2.2 kernels don't seem to have the KERNEL_VERSION macro.
#ifndef KERNEL_VERSION
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#endif

#include <sys/io.h>             /* outb, inb */

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,2,0)
#else
#include <asm/io.h>
#endif

#else

/* don't do it */
#ifndef UNDER_CE
#include <stdio.h>
#endif

static unsigned char parport[PARPORT_IO_WIDTH] = {0xFF, 0xFF, 0xFF};

static int ioperm(unsigned int addr, int width, int on)
{
  return 0;
}

static unsigned char inb(unsigned int port)
{
  int index;

  index = port - PARPORT_IO_ADDRESS;
  if (index < 0 ||
      index >= PARPORT_IO_WIDTH)
    {
      printf("inb: address out of bounds: %X\n", port);
      return 0;
    }

  return parport[index];
}

static void outb(unsigned char byte, unsigned int port)
{
  int index;

  index = port - PARPORT_IO_ADDRESS;
  if (index < 0 ||
      index >= PARPORT_IO_WIDTH)
    {
      printf("outb: address out of bounds: %X\n", port);
      return;
    }

  printf("outb: writing %X to %X\n", (int) byte, port);
  parport[index] = byte;
}

#endif

/* set up bits for R/W. In this case, they're not programmable by
   register so nothing need be done. */
int pptDioInit(const char * stuff)
{
  int retval = 0;

#ifdef linux
#if !defined(rtlinux) && !defined(rtai)
  /* turn on port access */
  retval = ioperm(PARPORT_IO_ADDRESS, PARPORT_IO_WIDTH, 1);
  if(retval) retval=iopl(3);
#endif
#endif

  return retval;
}

int pptDioQuit()
{
  int retval = 0;

#if !defined(rtlinux) && !defined(rtai)
  /* turn off port access */
  retval = ioperm(PARPORT_IO_ADDRESS, PARPORT_IO_WIDTH, 0);
#endif

  return retval;
}

/*
  Digital I/O

  Bitmap:
  Data Out        W   Base+0      D0-D7   8 LS TTL outputs
  Status In       R   Base+1      S3-S7   5 LS TTL inputs
  Control Out     W   Base+2      C0-C3   4 TTL Open Collector outputs

 */

int pptDioMaxInputs()
{
  return 5;
}

int pptDioMaxOutputs()
{
  return 12;
}

/*
  pptDioRead() maps 5 index values 0-4 onto S3-S7, respectively,
  providing 5 digital inputs

  Note that S7=4 is reverse polarity.
  */

int pptDioRead(int index, int *value)
{
  unsigned char inByte;
  unsigned char mask = 8;       /* start at 00001000 for S3 */

  if (index < 0 ||
      index > 4)
    {
      *value = 0;
      return -1;
    }

  /* latch input */
  inByte = inb(PARPORT_IO_ADDRESS + 1);
  mask <<= index;
  *value = (inByte & mask) ? 1 : 0;

  return 0;
}

/*
  pptDioCheck() maps 8 index values 0-7 onto D0-D7, respectively, and
  4 index values 8-11 onto C0-C3, respectively, providing read checks
  on the 12 digital outputs.

  Note that C0, C1, and C3 are inverted outputs; 'value' will return
  what was written to these, so checking a 1 means a 1 was last written
  and the output is 0V.
  */

int pptDioCheck(int index, int *value)
{
  unsigned char inByte;
  unsigned char mask = 1;       /* start at 00000001 for D0, C0 */

  if (index < 0 ||
      index > 11)
    {
      return -1;
    }

  if (index < 8)
    {
      inByte = inb(PARPORT_IO_ADDRESS);
      mask <<= index;
      *value = (inByte & mask) ? 1 : 0;
      return 0;
    }

  /* else index is 8-11 */
  inByte = inb(PARPORT_IO_ADDRESS + 2);
  mask <<= index - 8;
  *value = (inByte & mask) ? 1 : 0;
  return 0;
}

/*
  pptDioWrite() maps 8 index values 0-7 onto D0-D7, respectively, and
  4 index values 8-11 onto C0-C3, respectively, providing 12 digital outputs.

  Note that C0, C1, and C3 are inverted outputs.
  */
int pptDioWrite(int index, int value)
{
  unsigned char outByte;
  unsigned char mask = 1;       /* start at 00000001 for D0, C0 */

  if (index < 0 ||
      index > 11)
    {
      return -1;
    }

  if (index < 8)
    {
      /* read current outputs */
      outByte = inb(PARPORT_IO_ADDRESS);
      mask <<= index;
      if (value)
        {
          outByte |= mask;
        }
      else
        {
          outByte &= ~mask;
        }
      outb(outByte, PARPORT_IO_ADDRESS);
      return 0;
    }

  /* read current outputs */
  outByte = inb(PARPORT_IO_ADDRESS + 2);
  mask <<= index - 8;
  if (value)
    {
      outByte |= mask;
    }
  else
    {
      outByte &= ~mask;
    }
  outb(outByte, PARPORT_IO_ADDRESS + 2);
  return 0;
}

int pptDioByteRead(int index, unsigned char *byte)
{
  if (index != 0)
    {
      *byte = 0;
      return -1;
    }

  *byte = inb(PARPORT_IO_ADDRESS + 1);
  *byte >>= 3;                  /* shift down since S3 is bit 0, etc. */
  return 0;
}

int pptDioShortRead(int index, unsigned short *sh)
{
  if (index != 0)
    {
      *sh = 0;
      return -1;
    }

  *sh = (unsigned short) inb(PARPORT_IO_ADDRESS + 1);
  *sh >>= 3;                    /* shift down since S3 is bit 0, etc. */
  return 0;
}

int pptDioWordRead(int index, unsigned int *word)
{
  if (index != 0)
    {
      *word = 0;
      return -1;
    }

  *word = (unsigned int) inb(PARPORT_IO_ADDRESS + 1);
  *word >>= 3;                  /* shift down since S3 is bit 0, etc. */
  return 0;
}

int pptDioByteWrite(int index, unsigned char byte)
{
  if (index == 0)
    {
      outb(byte, PARPORT_IO_ADDRESS);
      return 0;
    }

  if (index == 1)
    {
      outb(byte, PARPORT_IO_ADDRESS + 2);
      return 0;
    }

  return -1;
}

int pptDioShortWrite(int index, unsigned short sh)
{
  return pptDioByteWrite(index, (unsigned char) sh);
}

int pptDioWordWrite(int index, unsigned int word)
{
  return pptDioByteWrite(index, (unsigned char) word);
}

int pptDioByteCheck(int index, unsigned char *byte)
{
  if (index == 0)
    {
      *byte = inb(PARPORT_IO_ADDRESS);
      return 0;
    }

  if (index == 1)
    {
      *byte = inb(PARPORT_IO_ADDRESS + 2);
      return 0;
    }

  *byte = 0;
  return -1;
}

int pptDioShortCheck(int index, unsigned short *sh)
{
  unsigned char b0, b1;

  if (index != 0)
    {
      *sh = 0;
      return -1;
    }

  b0 = inb(PARPORT_IO_ADDRESS);
  b1 = inb(PARPORT_IO_ADDRESS + 2);

  *sh = b1;
  *sh <<= 8;
  *sh += b0;

  return 0;
}

int pptDioWordCheck(int index, unsigned int *word)
{
  unsigned char b0, b1;

  if (index != 0)
    {
      *word = 0;
      return -1;
    }

  b0 = inb(PARPORT_IO_ADDRESS);
  b1 = inb(PARPORT_IO_ADDRESS + 2);

  *word = b1;
  *word <<= 8;
  *word += b0;

  return 0;
}

#ifdef MAIN

static void fillIn(int *ins)
{
  int t;

  for (t = 0; t < 5; t++)
    {
      pptDioRead(t, &ins[t]);
    }
}

static void printIn(int *ins)
{
  int t;

  for (t = 0; t < 5; t++)
    {
      printf("%d ", ins[t]);
    }
  printf("\n");
}

static void fillOut(int *outs)
{
  int t;

  for (t = 0; t < 12; t++)
    {
      pptDioCheck(t, &outs[t]);
    }
}

static void printOut(int *outs)
{
  int t;

  for (t = 0; t < 12; t++)
    {
      printf("%d ", outs[t]);
    }
  printf("\n");
}

int main(int argc, char *argv[])
{
  int t;
#define INPUTLEN 256
  char input[INPUTLEN];
  char cmd[INPUTLEN];
  int ins[5];
  int outs[12];
  int index;

  /* check -addr 0x378 */
  for (t = 1; t < argc; t++)
    {
      if (!strcmp(argv[t], "-addr"))
        {
          if (t == argc - 1)
            {
              fprintf(stderr, "no address specified\n");
              exit(1);
            }
          else if (1 != sscanf(argv[t+1], "%li", &PARPORT_IO_ADDRESS))
            {
              fprintf(stderr, "bad address specified: %s\n", argv[t+1]);
              exit(1);
            }
          else
            {
              t++;              /* step over address */
              continue;
            }
        }
      else
        {
          fprintf(stderr, "syntax: %s -addr <io address>\n", argv[0]);
          exit(1);
        }
    }

  if (-1 == pptDioInit(0))
    {
      fprintf(stderr, "can't init\n");
      exit(1);
    }

  while (! feof(stdin))
    {
      printf("ppt> ");
      fflush(stdout);

      if (NULL == fgets(input, INPUTLEN, stdin))
        {
          /* EOF */
          break;
        }

      if (1 != sscanf(input, "%s", cmd))
        {
          /* blank line-- print input */
          fillIn(ins);
          printIn(ins);
          continue;
        }

      if (! strcmp(cmd, "help") ||
          ! strcmp(cmd, "?"))
        {
          printf("help/?           print this help\n");
          printf("s <#>            set bit #\n");
          printf("c <#>            clear bit #\n");
          printf("k                check outputs\n");
          printf("ENTER            print inputs\n");
          printf("q                quit\n");
        }
      else if (! strcmp(cmd, "s"))
        {
          /* set */
          if (1 != sscanf(input, "%*s %d", &index))
            {
              printf("bad input: %s\n", input);
              continue;
            }

          if (0 != pptDioWrite(index, 1))
            {
              printf("index out of range\n");
            }
        }
      else if (! strcmp(cmd, "c"))
        {
          /* set */
          if (1 != sscanf(input, "%*s %d", &index))
            {
              printf("bad input: %s\n", input);
              continue;
            }

          if (0 != pptDioWrite(index, 0))
            {
              printf("index out of range\n");
            }
        }
      else if (! strcmp(cmd, "k"))
        {
          /* check outputs */
          fillOut(outs);
          printOut(outs);
        }
      else if (! strcmp(cmd, "q"))
        {
          break;
        }
      else
        {
          printf("?\n");
        }
    }

  pptDioQuit();

  exit(0);
}

#endif

---