Search  

---

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

Go to the documentation of this file.

#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/sched.h>
#include <sys/psinfo.h>
#include <sys/_devdrvr.h>
#include <sys/kernel.h>
#include <sys/ser_msg.h>
#include "struct.h"

#define PCMCIA

#ifdef PCMCIA
#include <sys/proxy.h>
#include <sys/pcmcia.h>

pcmcia_t pcmcia_handle;
pid_t pcmcia_proxy;
struct _pcmcia_io card_info;
#endif

/*
   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;

/*
 * Receive message buffer
 */

union _async_msg {
   msg_t             type;
   msg_t             status;
   struct _ser_reset    reset;
   struct _ser_reset_reply reset_reply;
   struct _ser_query    query;
   struct _ser_query_reply query_reply;
   } msg;

/*
 * Request from user for an option to set the initial state of RTS/CTS
 * (for use with multi-drop lines)
 */

int num_asyncs = 0;
long divisor;        // baudrate divisor, assumes on clock for all chips

struct dev_entry dev_table[MAX_ASYNCS];
struct dev_entry *dev_list[MAX_IRQS];

struct device_ctrl ctrl[MAX_ASYNCS];
struct dev_mode dmode[MAX_ASYNCS];
struct driver_ctrl drv_ctrl;

unsigned isize, osize, csize, high, low, sflow, hflow, raw, mode;
int threshold = 0;
long baud;
int uses_pcmcia = 0;
pid_t pcmcia_proxy = -1;
char *prefix = "ser";

int dev_handle;

void terminate( int signal )
   {
   int index;

   switch(signal) {
   default:
   case SIGTERM:
      /*
       * Shutdown by signal
       */
      dev_drvr_shutdown( dev_handle );
      /*
       * We should give back any GDT's, etc. that
       * the system doesn't release for us
       */
      break;

   case SIGPWR:
      for(index = 0; index < num_asyncs; ++index) {
         if(dev_table[index].mode & MODE_PWR) {
            shutdown_async(index);
            }
         }
      break;
      }
   exit(0);
   }

main(argc, argv)
int argc; char *argv[];
   {
   int tty, i;
   int index = 0;
   int arg;
   unsigned base, irq;
   unsigned slot;
   register char *p;
   char *p1;
   struct input_buffer far *ibuf;
   struct output_buffer far *obuf;
   struct termios far *tios;
   pid_t pid;
   msg_t t;
   int nbytes;
#ifdef PCMCIA
   struct dev_entry *dev;
#endif

   setscheduler(0, SCHED_RR, 20);

   /*
    * Allow only SIGTERM, which we catch and cause
    * graceful termination, all others are ignored
    */
   for( i = _SIGMIN; i <= _SIGMAX; ++i)
      if( i != SIGTERM  &&  i != SIGPWR)
         signal( i, SIG_IGN );

   signal( SIGTERM, &terminate );
   signal( SIGPWR, &terminate );

   init_tables();

   /*
    * Setup Defaults
    */

   base = 0;
   irq = 4;

   isize = 2048;
   osize = 2048;
   csize = 256;
   high = -1;
   low = -1;
   baud = 9600;
   raw = 1;
   hflow = 1;
   sflow = 0;
   mode = (MODE_DTR | MODE_RTS | MODE_SPLIT);
   divisor = 115200L; /* divisor for baud rate */

   /*
    * Scan the arguments
    */

   for(arg = 1; arg < argc; ++arg) {
      p = argv[arg];
      if(*p == 0)
         continue;
      if(*p == '-') {
         while(*++p) {
            switch(*p) {
            case 'b':
               baud =  atol(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'C':
               csize = atoi(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'd':
               mode |= MODE_DTR;
               continue;
            case 'D':
               mode &= ~MODE_DTR;
               continue;
            case 'e':
               raw = 0;
               continue;
            case 'E':
               raw = 1;
               continue;
            case 'f':
               hflow = 1;
               continue;
            case 'F':
               hflow = 0;
               continue;
            case 'h':
               high =  atoi(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'I':
               isize = atoi(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'm':
               mode |= MODE_NOHUP;
               continue;
            case 'M':
               mode &= ~MODE_NOHUP;
               continue;
            case 'N':
               prefix =     *(p+1) ? p+1 : argv[++arg];
               break;
            case 'O':
               osize = atoi(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'l':
               low =   atoi(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'p':
               mode |= MODE_PKT;
               continue;
            case 'P':
               mode &= ~MODE_PKT;
               continue;
            case 'r':
               mode |= MODE_RTS;
               continue;
            case 'R':
               mode &= ~MODE_RTS;
               continue;
            case 's':
               mode |= MODE_SPLIT;
               continue;
            case 'S':
               mode &= ~MODE_SPLIT;
               continue;
            case 't':
               threshold = atoi(*(p+1) ? p+1 : argv[++arg]);
               break;
            case 'w':
               mode |= MODE_PWR;
               continue;
            case 'W':
               mode &= ~MODE_PWR;
               continue;
            case 'x':
               sflow = 1;
               continue;
            case 'X':
               sflow = 0;
               continue;
            case 'y':
               divisor = atol(*(p+1) ? p+1 : argv[++arg]);
               break;

               } /* switch */

            } /* while */

         continue;
         } /* if */

      else {
         /*
          * Got a new ioport[,irq[,'p']] or 'p'n[,n[,...]]
          */
         p1 = p;
         while(*p  &&  *p != ',') ++p;
         if(*p == ',')
            *p++ = 0;
         slot = 0;
         if(*p1 == 'p') {
             ++p1;
            while(*p1) {
               i = atoi(p1);
               if(i >= 1  &&  i <= 16)
                  slot |= 1 << (i - 1);
               p1 = p;
               while(*p  &&  *p != ',') ++p;
               if(*p == ',')
                  *p++ = 0;
               }
            base = 0;
            irq = 0;
            }
         else {
            base = atoh(p1);
            irq = 4;
            if(*p) {
               p1 = p;
               while(*p  &&  *p != ',') ++p;
               if(*p == ',')
                  *p++ = 0;
               irq = atoi(p1);
               if(*p == 'p')
                  slot = -1;
               }
            }
         new_async(num_asyncs++, base, irq, slot);
         }

      } /* for */

   /*
    * If no serial ports are given, then scan for all that exist
    * with the last state of the global options
    */
   if(num_asyncs == 0) {
      num_asyncs = find_asyncs();
      if(num_asyncs == 0)
         exit(0); /* terminate quietly if no serial ports */
      }

   if(num_asyncs <= 0  ||  num_asyncs >= MAX_ASYNCS) {
      exit(ERANGE);
      }

   /*
    * Register ourselves with the DEVICE Manager
    */

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

   tty = drv_ctrl.base_tty;

   /*
    * Create each of the devices now
    */

   for(index = 0; index < num_asyncs; ++index) {

      /*
       * Get a tty number, and allocate input/output buffers
       */

      if(dev_drvr_mount(dev_handle, tty, 1, &ctrl[index])) {
         dev_drvr_shutdown( dev_handle );
         exit(ENOMEM);
         }

      dev_table[index].tty = ctrl[index].tty;
      dev_table[index].obuf = ctrl[index].obuf;
   
      /*
       * Setup TERMIOS defaults
       */
      tios = ctrl[index].termios;
      tios->handle = index;
      if(dmode[index].raw) {
         tios->c_iflag      = 0;
         tios->c_oflag      = 0;
         tios->c_lflag      = (IEXTEN);
         tios->c_cflag      = (CREAD|CS8);
         tios->c_ispeed     = dev_table[index].baud;
         tios->c_ospeed     = dev_table[index].baud;
         tios->c_cc[VEOF]   = 0x00;
         tios->c_cc[VEOL]   = 0x00;
         tios->c_cc[VERASE]    = 0x00;
         tios->c_cc[VINTR]  = 0x00;
         tios->c_cc[VKILL]  = 0x00;
         tios->c_cc[VQUIT]  = 0x00;
         tios->c_cc[VSUSP]  = 0x00;
         tios->c_cc[VSTART]    = 0x11;
         tios->c_cc[VSTOP]  = 0x13;
         tios->c_cc[VMIN]   = 0x01;
         tios->c_cc[VTIME]  = 0x00;
         }
      else {
         tios->c_iflag      = (BRKINT|IXON|ICRNL);
         tios->c_oflag      = (OPOST);
         tios->c_lflag      = (ISIG|ICANON|ECHO|ECHOK|ECHOE|IEXTEN);
         tios->c_cflag      = (CREAD|CS8);
         tios->c_ispeed     = dev_table[index].baud;
         tios->c_ospeed     = dev_table[index].baud;
         tios->c_cc[VEOF]   = 0x04;
         tios->c_cc[VEOL]   = 0x00;
         tios->c_cc[VERASE]    = 0x7F;
         tios->c_cc[VINTR]  = 0x03;
         tios->c_cc[VKILL]  = 0x15;
         tios->c_cc[VQUIT]  = 0x00;
         tios->c_cc[VSUSP]  = 0x00;
         tios->c_cc[VSTART]    = 0x11;
         tios->c_cc[VSTOP]  = 0x13;
         tios->c_cc[VMIN]   = 0x01;
         tios->c_cc[VTIME]  = 0x00;
         }

      if(dmode[index].hflow) {
         tios->c_cflag |= (IHFLOW|OHFLOW);
         tios->c_qflag |= TC_PROTECT_HFLOW; /* Lock it on! */
         }

      if(dmode[index].sflow) {
         tios->c_iflag |= (IXON|IXOFF);
         tios->c_qflag |= TC_PROTECT_SFLOW; /* Lock it on! */
         }
   
      /*
       * Setup Output port handle
       */
      obuf = ctrl[index].obuf;
      obuf->handle = index;
      if(dmode[index].raw == 0)
         obuf->mode |= OUTPUT_XNL;
   
      /*
       * Setup default control parameters
       */
      ibuf = ctrl[index].ibuf;
      ibuf->handle = index;
      ibuf->sw_high_water = dmode[index].high;
      ibuf->sw_low_water = dmode[index].low;
      ibuf->hw_high_water = dmode[index].high+2;
      ibuf->hw_low_water = dmode[index].low-2;

      /*
       * Initialize Device
       */
      init(index, dev_table[index].iobase, dev_table[index].irq,
         dev_table[index].baud, dmode[index].mode);
   
      /*
       * Start up the device
       */
      if(dev_drvr_arm(tty)) {
         dev_drvr_shutdown( dev_handle );
         exit(ENODEV);
         }

      ++tty;
      }

#ifdef PCMCIA     
   if(uses_pcmcia) {
      pcmcia_proxy = qnx_proxy_attach(0, 0, 0, -1);
      pcmcia_handle = qnx_pcmcia_io_attach(0);
      qnx_pcmcia_io_arm(pcmcia_handle, _PCMCIA_DEV_SERIAL, -pcmcia_proxy);
      /*
       * Kick a proxy now so that main loop will wake up and
       * scan for installed pcmcia cards right away
       */
      Trigger(pcmcia_proxy); 
      }
#endif

   /*
    * 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 );

   /*
    * Wait for Control messages.
    * The interrupt handlers will take care of ALL I/O
    */

   for(;;) {
      if((pid = Receive(0, &msg, sizeof(msg))) == -1)
         continue;

#ifdef PCMCIA
      if(pid == pcmcia_proxy) {
         while(qnx_pcmcia_io_info(pcmcia_handle, _PCMCIA_DEV_SERIAL,
               &card_info) != -1) {

            slot = 1 << card_info.socket;
            base = card_info.base;
            irq = card_info.irq;
   
            if(card_info.flags & _PCMCIA_FLAG_CARD) {
   
               /*
                * Scan for the device corresponding to this slot/port
                */
               dev = &dev_table[0];
               for(index = 0; index < num_asyncs; ++index) {
                  if((dev->slots & slot) != 0
                         && (dev->iobase == 0 || dev->iobase == base) )
                     break;
                  ++dev;
                  }
               if(index >= num_asyncs)
                  continue;
   
               /*
                * The card is now plugged in
                * Reset the hardware registers to match the software state
                * and link in to the appropriate interrupt chain.
                */
               if(qnx_pcmcia_io_lock(pcmcia_handle, card_info.socket,
                     card_info.index) != -1) {
                  if(dev->slots != -1) {
                     dev->iobase = base;
                     dev->irq = irq;
                     }
                  dev->slot = card_info.socket + 1;
                  reset_async( index, 1 );
                  dev->mode |= MODE_AVAILABLE;
                  /*
                   * Tell Dev that the output buffer has
                   * a size > 0 which will allow write() to succeed.
                   */
                  ctrl[index].obuf->length = ctrl[index].osize;
                  }
               }
            else {
               /*
                * Scan for the device corresponding to this slot/port
                */
               dev = &dev_table[0];
               for(index = 0; index < num_asyncs; ++index) {
                  if((dev->slots & slot) != 0 && dev->iobase == base )
                     break;
                  ++dev;
                  }
               if(index >= num_asyncs)
                  continue;
   
               /*
                * A card is now unplugged
                */
               if(dev->mode & MODE_AVAILABLE) {
                  dev->mode &= ~MODE_AVAILABLE;

                  disable_irq( index );

                  if(dev->slots != -1) {
                     dev->iobase = 0;
                     dev->irq = 0;
                     }
                  dev->slot = 0;
                  /*
                   * Temporarily tell Dev that the output buffer has
                   * a size of zero bytes, which means treat as NULL
                   * device on writes()
                   */
                  ctrl[index].obuf->length = 0;

                  qnx_pcmcia_io_unlock(pcmcia_handle, card_info.socket,
                        card_info.index);
                  }
               }
            continue;
            }
         }
#endif

      t = msg.type;
      msg.status = ENOSYS;
      nbytes = sizeof(msg.status);

      switch(t) {

      case 0:
         nbytes = sys_msg(&msg);
         break;

      case _SER_RESET:
         index = msg.reset.unit;
         if(index < 0  ||  index >= num_asyncs) { 
            msg.status = EINVAL;
            }
         reset_async( index, 1 );
         memset( &msg, 0, sizeof(msg.reset_reply) );
         msg.reset_reply.status = EOK;
         break;

      case _SER_QUERY:
         index = msg.query.unit;
         memset( &msg, 0, sizeof(msg.query_reply) );
         if(index < 0  ||  index >= num_asyncs) { 
            msg.status = EINVAL;
            }
         else {
            struct dev_entry *dev;
            dev = &dev_table[index];
            msg.query_reply.status = EOK;
            msg.query_reply.iobase = dev->iobase;
            msg.query_reply.irq    = dev->irq;
            msg.query_reply.mode   = dev->mode;
            msg.query_reply.slots  = dev->slots;
            msg.query_reply.slot   = dev->slot;
// New in 4.23
            msg.query_reply.rx_count = dev->rx_count;
            msg.query_reply.tx_count = dev->tx_count;
            msg.query_reply.cur_state = (dev->modem_status & 0xF0)
                                 | (dev->modem_control & 0x03);
            }
         nbytes = sizeof(msg.query_reply);
         break;

      default:
         break;
         }

      if(nbytes)
         Reply( pid, &msg, nbytes);
      }
   }

/*
 * Create a new device entry based on current values
 * in global variables
 */

new_async(index, iobase, irq, slots)
int index;
unsigned iobase, irq;
unsigned slots;
   {

   /*
    * Limit values to reasonable range
    */
   if(isize <  16)
      isize = 16;
   if(osize < 16)
      osize = 16;
   if(csize < 16)
      csize = 16;
   if(high == -1)
      high = isize / 4 * 3;
   if(high > (isize - 4))
      high = isize - 4;
   if(low == -1)
      low = isize / 4;
   if(low > (high - 4))
      low = high - 4;

   ctrl[index].isize = isize;
   ctrl[index].osize = osize;
   ctrl[index].csize = csize;

   dmode[index].raw = raw;
   dmode[index].hflow = hflow;
   dmode[index].sflow = sflow;
   dmode[index].mode = mode;
   dmode[index].high = high;
   dmode[index].low = low;

   dev_table[index].threshold = threshold;
   dev_table[index].iobase = iobase;
   dev_table[index].irq = irq;
   dev_table[index].baud = baud;
   dev_table[index].slots = slots;

   if(slots != 0)
      uses_pcmcia = 1;

   return(0);
   }

---