Search  

---

C:/temp/src/j2k/QNX4/driver/Par2/main.c

Go to the documentation of this file.

#include <i86.h>
#include <conio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/sched.h>
#include <sys/osinfo.h>
#include <sys/psinfo.h>
#include <sys/utsname.h>
#include <sys/_devdrvr.h>
#include <sys/kernel.h>
#include <sys/proxy.h>

#include "par.h"

/*
   declare the calls 'dev' will make into driver.
*/
int far  Kick  (struct output_buffer far *obuf);
int far  Stty  (struct termios far *tios); 
int far  Ctrl (union ioctl_entry far *ioc); 

#pragma aux (_dev_call) Kick;
#pragma aux (_dev_call) Stty;
#pragma aux (_dev_call) Ctrl;

union _printer_msg {
  msg_t  type;
  msg_t  status;
  char   filer[100];
} msg;

int idle = 1;
volatile int  dangerous = 0;

unsigned port = 0;
int biosport  = 1;
int osize     = 1000;

/* 10 msec nap time */
#define  NAP_TIME       10
#define  NAPS_PER_SEC   (1000/NAP_TIME)
#define  nap()          (delay(NAP_TIME))

unsigned ioport = 0;
unsigned cpu_speed;
long     usec_wait = 1000; /* 1 msec default */
long     io_retry;

int      check_open = 0;
int      rtimeout   = -1;

struct driver_ctrl drv_ctrl;
struct device_ctrl ctrl;

/* Name will be  /dev/board1 */
char* prefix = "board";

#define  peekch(obuf)         (*(obuf)->tail)
#define  abort_output(obuf)   ( (obuf)->discard = (obuf)->size)

int dev_handle;

void terminate( int signal ) {
 if (signal) {
   /* Shutdown by signal */
   dev_drvr_shutdown( dev_handle );

    /* We should give back any GDT's, etc.    */
    /* that the system doesn't release for us */
 }
 exit(0);
}

void main( int argc, char* argv[] ) {
  unsigned c;
  struct _osinfo osinfo;
  int i;
  int priority = 9;
  struct termios far *tios;

  /* Allow only SIGTERM, which we catch and cause */
  /* graceful termination, all others are ignored */

  for( i = _SIGMIN; i <= _SIGMAX; i++)
    if ( i != SIGTERM )
      signal( i, SIG_IGN );

  signal( SIGTERM, &terminate );

  /* Scan arguments */

  while ((c=getopt(argc,argv,"cO:N:p:b:w:s:P:")) != -1) {
    switch (c) {
      case  'c':
        check_open = 1;
        break;
      case  'O':
        osize = strtol(optarg,NULL,0);
        break;
      case  'N':
        prefix = optarg;
        break;
      case  'p':
        ioport = strtol(optarg,NULL,16);
        break;
      case  'b':
        biosport = strtol(optarg,NULL,16);
        break;
      case  's':
        if ((rtimeout = strtol(optarg,NULL,10) * NAPS_PER_SEC) == 0) {
          rtimeout = 1;  /* sleep at least once... */
        }
        break;
      case  'w':
        usec_wait = strtol(optarg,NULL,0);
        break;
      case  'P':
        priority = strtol(optarg,NULL,0);
        break;
    }
  } // End of which()

  setscheduler(0, SCHED_FAIR, priority);

  if (ioport == 0) {
    ioport = next_printer(biosport);
    if (ioport == 0)
       exit(0); /* Terminate quietly if no parallel ports */
  }

  qnx_osinfo((nid_t) 0, &osinfo);
  cpu_speed = osinfo.cpu_speed;
  io_retry = (cpu_speed / 100) *  usec_wait;

  /* Register ourselves with the DEVICE Manager */

  if ((dev_handle = dev_drvr_register( "elan104board", prefix, 1,
               &Kick, &Stty, &Ctrl, &drv_ctrl, 0)) == -1)
  {
    exit(ENFILE);
  }

  /* Allocate the resources for this device */

  ctrl.isize = 0;
  ctrl.osize = osize;
  ctrl.csize = 0;

  if (dev_drvr_mount(dev_handle, drv_ctrl.base_tty, 1, &ctrl)) {
    dev_drvr_shutdown( dev_handle );
    exit(ENOMEM);
  }
   
  /* Initialize 'stty' settings to consistent values */
  ctrl.obuf->mode |= OUTPUT_XNL;

  tios = ctrl.termios;
  tios->c_cflag = (CS8);
  tios->c_oflag = (OPOST);
  tios->c_iflag = 0;
  tios->c_lflag = 0;
  tios->c_ispeed = 0L;
  tios->c_ospeed = 9600L;

  /* OUTPUT DRIVER */
  init_printer(ioport);
  idle = 0;
  port = qnx_proxy_attach(0, 0, 0, -1);

  /* Let DEV call us now */

  if (dev_drvr_arm(ctrl.tty)) {
    dev_drvr_shutdown( dev_handle );
    exit(ENODEV);
  }

  /*
   * Close off stdin,stdout,stderr since this process
   * is usually started in sysinit as a background process,
   * by the shell, which typically sets stdin to /dev/null
   * (on the machine we booted from), which ties up resources
   */
   close(0);
   close(1);
   close(2);

   qnx_pflags( _PPF_SERVER, _PPF_SERVER, 0, 0 );


#define GAURD(X)  ((dangerous=1),(X),(dangerous=0))

   for(;;) {
      GAURD(idle = (ctrl.obuf->size == 0));

      if (idle) {
        /* If nothing to print (at this time)        */
        /* then set flag and wait for DEV to Kick us */

        wait_msg(port);
        continue;    
      }

      if (flush_buffer(ctrl.obuf)) {
        continue;
      }

      /* Get the next character to print */
      /* from the output buffer          */
      if ((c=peekch(ctrl.obuf)) == '\n' && (ctrl.obuf->mode & OUTPUT_XNL)) {
         if (outch('\r',ctrl.obuf) == -1) {  /* failed on a write */
           abort_output(ctrl.obuf);
           continue;
         }
      }

      if (outch(c,ctrl.obuf) == -1) {
        abort_output(ctrl.obuf);
        continue;
      }

      /* If we broke out because of a request to flush
       * output, then start the loop over without printing
       * this character
       */

      advance(ctrl.obuf);
      }
   }

short prtready(port,strict)
   {
   short c;

   c = inp(port+REG_STAT);
   return strict ?
         (c&STATUS_MASK) == STATUS_OK :
         (c&NOTBUSY) == NOTBUSY;
   }


outch(int ch, const struct output_buffer far *obuf)
   {
   int   tick;
   long  x;

   /*
    * Wait (possible forever) for BUSY to go off
    */
   for (tick=rtimeout,x=io_retry;  !prtready(ioport,0);) {
      if (obuf->discard)
         return -1;
      if (x--)
         continue;
      x = io_retry;
      nap();
      if (tick != -1) {
         if (--tick == 0) {
            return -1;
            }
         }
      }
   /*
    * Write the character
    */
   outp(ioport, ch);

   /*
    * Pulse the strobe line
    */
   udelay(2);

   outp(ioport + REG_CNTL, 0x0D );
   udelay(1); /* Wait a bit (scaled on CPU speed) */
   outp(ioport + REG_CNTL, 0x0C );
   udelay(2);
   return 0;
   }  

/*
 * Kick is called by DEV everytime something "new" happens
 * to the output buffer
 *
 * It will set 'obuf' to be the output buffer
 * It will also set ds to be the data segment of the driver being called
 *
 * Since this routine is "called" by DEV, it will ALWAYS run at higher
 * priority than the driver task, so cannot be interrupted.
 */

int far Kick (struct output_buffer far *obuf)   {
   if(obuf->size > 0) {
      if(idle || dangerous) {
         idle = 0;
         Trigger(port);
         }
      return(1);
      }
   return(0);
   }

/*
 * Stty is called by DEV to indicate a significant change in the
 * termios control structure (baud rate, modem control)
 *
 * It will set 'tios' to be a far pointer to the termios entry
 * It will also set ds to be the data segment of the driver being called
 *
 * Since this routine is "called" by DEV, it will ALWAYS run at higher
 * priority than the driver task, so cannot be interrupted.
 */


int far Stty (struct termios far *tios)
   {
   unsigned cflags;

   /*
    * Use 'tios' to keep the compiler happy
    */
   cflags = tios->c_cflag;

   return(0);
   }

/*
 * Ctrl is called by DEV to indicate a high level
 * control function
 *
 * It will set 'ioc' to be an ioctl control block
 * It will also set ds to be the data segment of the driver being called
 *
 * Since this routine is "called" by DEV, it will ALWAYS run at higher
 * priority than the driver task, so cannot be interrupted.
 */

int far Ctrl (union ioctl_entry far *ioc)
   {
   int type;

   type = ioc->type;
   ioc->status = IOCTL_ERROR;
   switch (type) {
   case  IOCTL_OPEN:
      ioc->status = (check_open && !prtready(ioport,1)) ? IOCTL_NONE_FREE
               : IOCTL_OK;
      return(0);
   case  IOCTL_CLOSE:
      ioc->status = IOCTL_OK;
      return(0);
   case  IOCTL_CTL:  
      {
         unsigned unit = ioc->user.unit;
         unsigned char bits, mask, oldbits;

         if(unit > 1  ||  unit <= 0) {
            ioc->status = IOCTL_BAD_UNIT;
            return(0);
            }
         
         mask = ioc->user.data[4];
         bits = ioc->user.data[0];
         _disable();
         oldbits = inp( ioport + REG_STAT );
         outp( ioport + REG_STAT, (oldbits & ~mask) | (bits & mask));
         _enable();
         ioc->user_return.data[0] = oldbits;

         mask = ioc->user.data[5];
         bits = ioc->user.data[1];
         _disable();
         oldbits = inp( ioport + REG_CNTL );
         outp( ioport + REG_CNTL, (oldbits & ~mask) | (bits & mask));
         _enable();
         ioc->user_return.data[1] = oldbits;

         ioc->user_return.data[2] = 0;
         ioc->user_return.data[3] = 0;
         ioc->user_return.nbytes = 4;
         ioc->user_return.status = IOCTL_OK;
         return(0);
         }
      }
   return(-1);
   }

next_printer(unsigned n) {
   unsigned far *port;

   port = MK_FP(0x0040, (2*(n-1))+0x0008);
   n = *port;
   return(n);
   }


init_printer(port)
unsigned port;
   {
   outp(port + REG_CNTL, 0x0C );
   return(0);
   }


/*
 * Attempt to busy-wait for a number of microseconds
 */

udelay(usec)
unsigned usec;
   {
   unsigned i, u;

   for(i = 0; i < usec; ++i) {
      for(u = 0; u < cpu_speed; u+= 100)
         ;
      }
   return(0);
   }

wait_msg(pid_t port)
   {
   pid_t pid;
   int nbytes;
   extern int sys_msg(void *);

   while(1) {
      /*
       * Consume all messages from processes
       */
      if ((pid = Receive(0, &msg, sizeof(msg))) == port)
         break;
      /*
       * Otherwise, respond to message and wait for proxy
       */
      nbytes = 1;
      if(msg.type == 0)
         nbytes = sys_msg(&msg);
      else
         msg.status = ENOSYS;
      if(nbytes)
         Reply(pid, &msg, nbytes);
      }
   }

flush_buffer(struct output_buffer far *obuf)
   {
   int   i;
   int   n;

   _disable();
   if((n=obuf->discard) == 0) {
      _enable();
      return 0;
      }
   /*
    * Discard some (or all) data instead of displaying it
    */
   obuf->discard = 0;
   obuf->size -= n;
   _enable();
      
   i = &obuf->buffer[obuf->length] - obuf->tail;
   if(i > n)
      obuf->tail += n;
   else
      obuf->tail = &obuf->buffer[n-i];

   low_water(obuf);
   return 1;
   }

advance(struct output_buffer far *obuf)
   {
   /*
    * Advance tail pointer after character has been printed
    */
   ++obuf->tail;
   if(obuf->tail >= &obuf->buffer[obuf->length])
      obuf->tail = &obuf->buffer[0];

   /*
    * Decrement the queue size
    */
   _disable();
   --obuf->size;

   /*
    * If size of buffer drops below notification threshold,
    * inform DEV of the new information
    */
   low_water(obuf);
   return obuf->size != 0;
   } 
   
low_water(struct output_buffer far *obuf)
   {
   /*
    * Inform DEV if the output buffer is now
    * below the notification threshold
    */
   _disable();
   if(obuf->size < obuf->bcount) {
      obuf->bcount = 0;
      obuf->action |= ACT_OUTPUT_READY;
      _enable();
      Trigger(drv_ctrl.hw_pid);
      }
   else
      _enable();
   return 1;
   }

---