Search  

---

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

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/_devdrvr.h>
#include <sys/sched.h>
#include <sys/utsname.h>
#include <sys/osinfo.h>
#include <sys/psinfo.h>
#include <sys/kernel.h>
#include <sys/proxy.h>
#include <i86.h>
#include <conio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.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;

char *prefix = "par";

#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);
   }

main(argc, argv)
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;
         }
      }

   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("parallel", 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 );

   
   for(;;) {
   
#define GAURD(X)  ((dangerous=1),(X),(dangerous=0))

      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;
   }

---