---

ppmc_internal.c

Go to the documentation of this file.

//internal low level functions
//this is for 
//parport related functions
#include "ppmc.h"

#ifdef RTLINUX
#ifndef MODULE
#define MODULE
#endif
#define DO_IT
#endif


#ifdef LINUX
#define DO_IT
/*
  Compiling this for LINUX (not RTLINUX) means linking this into a Linux
  process, running non-real-time in user space. This is useful for debugging.
  If this is done, then the following stuff needs to be  done to access the
  IO space.
  */


#ifdef DEFINE_EXTERN_BEFORE_IO
/*
  Because of a limitation in gcc (present at least in 2.7.2.1 and below), you
  _have to_ compile any source code that uses these routines with optimisation
  turned on (gcc -O1 or higher), or alternatively #define extern to be
  empty before #including <asm/io.h>.
  */
#define extern
#endif


/*
  Need to access ports in range 0x278 - 0x378, for default
  PPMC base address. ioperm() only enables up to 0x3FF, so we need to use
  iopl() to grant full access to IO space.
  */

#include <unistd.h>             /* iopl() */

#endif /* LINUX  */

#ifdef linux
#include <linux/version.h>      /* LINUX_KERNEL_VERSION  */
#endif


#ifdef DO_IT

/* outb,inb already included by sys/io.h for 2.2 kernels  */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,0)
#include <asm/io.h>             /* outb, inb */
#else
#include <sys/io.h>             /* outb, inb */
#endif
#else

/* otherwise do nothing */

#include <stdio.h>

static int iopl(int level)
{
  return 0;
}

static unsigned char inb(unsigned int port)
{
  if (port >= STG_BASE_ADDRESS &&
      port <= STG_BASE_ADDRESS + 0x1f)
    {
      return 0;
    }

  if (port >= STG_BASE_ADDRESS + 0x400 &&
      port <= STG_BASE_ADDRESS + 0x400 + 0x1f)
    {
      return 0;
    }

  printf("inb: address out of bounds: %X\n", port);
  return 0;
}

static void outb(unsigned char byte, unsigned int port)
{
  /* allow writes to 0x80 for 1 msec delay */
  if (port == 0x80)
    {
      return;
    }

  if (port >= STG_BASE_ADDRESS &&
      port <= STG_BASE_ADDRESS + 0x1f)
    {
      return;
    }

  if (port >= STG_BASE_ADDRESS + 0x400 &&
      port <= STG_BASE_ADDRESS + 0x400 + 0x1f)
    {
      return;
    }

  printf("outb: address out of bounds: %X\n", port);
}

static unsigned short inw(unsigned int port)
{
  if (port % 2)
    {
      printf("inw: alignment error: %X\n", port);
      return 0;
    }

  if (port >= STG_BASE_ADDRESS &&
      port <= STG_BASE_ADDRESS + 0x1e)
    {
      return 0;
    }

  if (port >= STG_BASE_ADDRESS + 0x400 &&
      port <= STG_BASE_ADDRESS + 0x400 + 0x1e)
    {
      return 0;
    }

  printf("inw: address out of bounds: %X\n", port);
  return 0;
}

static void outw(unsigned short word, unsigned int port)
{
  if (port % 2)
    {
      printf("outw: alignment error: %X\n", port);
      return;
    }

  if (port >= STG_BASE_ADDRESS &&
      port <= STG_BASE_ADDRESS + 0x1e)
    {
      return;
    }

  if (port >= STG_BASE_ADDRESS + 0x400 &&
      port <= STG_BASE_ADDRESS + 0x400 + 0x1e)
    {
      return;
    }

  printf("outw: address out of bounds: %X\n", port);
  return;
}


#endif

//extern unsigned int stg_base_addr;
unsigned short STG_BASE_ADDRESS = DEFAULT_PPMC_BASE_ADDRESS;
#define ppmc_base_addr STG_BASE_ADDRESS
/*
        base+0          data
 *      base+1          status
 *      base+2          control
  *     base+3          EPP address
 *      base+4          EPP data
*/
#define SPPDATA ppmc_base_addr
#define STATUSPORT ppmc_base_addr+1
#define CONTROLPORT ppmc_base_addr+2
#define ADDRPORT ppmc_base_addr+3
#define DATAPORT ppmc_base_addr+4



void BusReset(void)
{
  outb(0,CONTROLPORT);
  outb(4,CONTROLPORT);
}

//internal routine to initialize the port itself
short InitializeParPort(void);
//internal routine to initialize the encoder board(s)

 int ClrTimeout(void)
{
        unsigned char r;

        if  (!(inb(STATUSPORT) & 0x01))
                return 0;

        /* To clear timeout some chips require double read */
        
        BusReset();
        r = inb(STATUSPORT);
        outb(r | 0x01, STATUSPORT); /* Some reset by writing 1 */
        r = inb(STATUSPORT);

        return !(r & 0x01);
}


void SelAddr(unsigned int port)
{
  /* writes a device address to the data port and toggles address strobe low, and waits
                for handshake */
    ClrTimeout();
    //    outb(inb(CONTROLPORT) & 0xDF,CONTROLPORT);  // set port direction to output
    outb(0x04,CONTROLPORT);  // set port direction to output
 
   outb(port,ADDRPORT);
    return;
}

void WriteData(unsigned char byte)
{
  /* writes data to the data port and toggles data strobe low, and waits
                for handshake */
    outb(byte,DATAPORT);
        ClrTimeout();
    return;
}
void WriteData16(unsigned short word)
{
  
    outb(word & 0x00FF,DATAPORT);
    outb(word >> 8,DATAPORT);
    return;
}
unsigned short ReadData(void)
  {
    //    outb(inb(CONTROLPORT) | 0x20,CONTROLPORT);  // set port direction to input
    outb(0x24,CONTROLPORT);  // set port direction to input
    return inb(DATAPORT);
    
  }

unsigned short SelRead(unsigned int port)
{
  /* writes a device address to the data port and toggles address strobe low, and waits
                for handshake, then inputs data byte and toggles data strobe low, then
                high again */
    ClrTimeout();
    outb(inb(CONTROLPORT) & 0xDF,CONTROLPORT);  // set port direction to output
    outb(port,ADDRPORT);
    outb(inb(CONTROLPORT) | 0x20,CONTROLPORT);  // set port direction to input
    return inb(DATAPORT);
    
}

void SelWrt(unsigned int port, unsigned char byte)
{
  /* writes a device address to the data port and toggles address strobe low, and waits
                for handshake, then outputs data byte and toggles data strobe low, then
                high again */
    ClrTimeout();
    //    outb(inb(CONTROLPORT) & 0xDF,CONTROLPORT);  // set port direction to output
    outb(0x04,CONTROLPORT);  // set port direction to output
    outb(port,ADDRPORT);
    outb(byte,DATAPORT);
    return;
}
void SelWrt16(unsigned int port, unsigned short word)
{
  /* writes a device address to the data port and toggles address strobe low, and waits
                for handshake, then (outputs data byte and toggles data strobe low, then
                high again) repeat for 2nd byte */
    ClrTimeout();
    outb(inb(CONTROLPORT) & 0xDF,CONTROLPORT);  // set port direction to output
    outb(port,ADDRPORT);
    outb(word & 0x00FF,DATAPORT);
    outb(word >> 8,DATAPORT);
    return;
}


short int InitializeParPort(void)
{
#ifdef LINUX
        ioperm(ppmc_base_addr,5,1) ;//turn on the 5
                        //if you want to run ecp, need to use iopl()
#endif
  return 0;
}

int ppmcMotInit(const char * stuffstuff)
{
        if(InitializeParPort()==-1)
                return -1;
        BusReset();
        if(EncoderInit()==-1)
                return -1;
        /*      if(DACInit()==-1)
                return -1;
        if(DIOInit()==-1)
        return -1;  */
  return 0;

}

int ppmcMotQuit()
{
        DACQuit();
        EncoderQuit();
        DIOQuit();
  return 0;
}

---