Search  

---

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

Go to the documentation of this file.

#include "struct.h"
#include <conio.h>
#include <i86.h>
#include <sys/irqinfo.h>
#include <sys/trace.h>
#include <sys/tracecod.h>

extern struct dev_entry dev_table[];
extern struct dev_entry *dev_list[];
extern struct driver_ctrl drv_ctrl;
extern int num_asyncs;
extern long divisor;

pid_t (far *tti)(int, int, unsigned);
unsigned tti_ds;

static char timer_enabled = 0;

static char int_enabled[16] ={
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

static unsigned irq_hdl[16] ={
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

pid_t (far *async_irq[16])();

void init_tables() {
   async_irq[0] = &async_irq0;
   async_irq[1] = &async_irq1;
   async_irq[2] = &async_irq2;
   async_irq[3] = &async_irq3;
   async_irq[4] = &async_irq4;
   async_irq[5] = &async_irq5;
   async_irq[6] = &async_irq6;
   async_irq[7] = &async_irq7;
   async_irq[8] = &async_irq8;
   async_irq[9] = &async_irq9;
   async_irq[10] = &async_irq10;
   async_irq[11] = &async_irq11;
   async_irq[12] = &async_irq12;
   async_irq[13] = &async_irq13;
   async_irq[14] = &async_irq14;
   async_irq[15] = &async_irq15;
   }

void init(index, base, irq, baud, mode)
int index;
unsigned base, irq;
long baud;
int mode;
   {
   register struct dev_entry *ttp;
   extern pid_t far poll_devices();

   /*
    * Get a free dev_entry
    */
   ttp = &dev_table[index];

   ttp->iobase = base;
   ttp->irq = irq;
   ttp->busy = 0;
   ttp->baud = baud;
   ttp->parity = 0;
   ttp->stop_bits = 1;
   ttp->data_bits = 8;
   ttp->mode = mode;
   ttp->modem_control = (inp(ttp->iobase+4) & 0xE4) | 0x08;
   if(mode & MODE_DTR)
      ttp->modem_control |= 1;
   if(mode & MODE_RTS)
      ttp->modem_control |= 2;

   /*
    * Tell irq handler(s) how to call Dev
    */
   tti = drv_ctrl.tti;
   tti_ds = drv_ctrl.tti_ds;

   /*
    * Only setup IRQ handler for non-pcmcia devices
    * pcmcia devices will have this done later when card is inserted
    */

   if(ttp->slots == 0  &&  irq > 0  &&  irq <= 15) {
      reset_async(index, 1);
      }

   if(timer_enabled == 0) {
      timer_enabled = 1;
      /*
       * Link into 100 msec timer chain
       */
      qnx_hint_attach( -1, &poll_devices, FP_SEG(&dev_table) );
      }

   }

/*
 * Default device scan
 */


int find_asyncs() {
   if(check_async(0x3f8))
         new_async(num_asyncs++, 0x3f8, 4, 0);
   if(check_async(0x2f8))
         new_async(num_asyncs++, 0x2f8, 3, 0);
   return(num_asyncs);
   }

static int check_async(unsigned port)
   {
   /*
    * Use Line control latch to determine if controller card is present
    */
   _disable();
   outp(port + 3, 0x05);
   if(inp(port + 3) == 0x05) {
      outp(port + 3, 0x0a);
      if(inp(port + 3) == 0x0a) {
         /*
          * Found one....
          * Clear any pending interrupts
          */
         outp(port + 1, 0x00);   /* Disable all interrupts */
         inp(port + 5);    /* Clear Line Status Interrupt */
         inp(port + 0);    /* Clear RX Interrupt */
         inp(port + 2);    /* Clear TX Interrupt */
         inp(port + 6);    /* Clear Modem Interrupt */
         _enable();
         return(1);
         }
      }
   _enable();
   return(0);
   }


/*
 * These routines are called by Stty(), so make SURE that
 * stack checking is OFF
 */
#pragma off (check_stack);

static void set_port(port, mask, data)
unsigned port, mask, data;
   {
   unsigned char c;
   c = inp(port);
   outp(port, (c & ~mask) | (data & mask));
   }

int reset_async(index, init)
int index;
int init;
   {
   register struct dev_entry *ttp;
   unsigned port;
   unsigned value;

   ttp = &dev_table[index];
   port = ttp->iobase;

   if(port == 0)
      return(0);

   /*
    * Set Baud rate
    */
   if(ttp->baud == 0)
      value = 0;
   else
      value = divisor / ttp->baud; /* calculate divisor for baud rate */

   _disable();
   set_port(port + 3, 0x80, 0x80);
   set_port(port + 0, 0xff, value & 0xff);
   set_port(port + 1, 0xff, value >> 8);
   set_port(port + 3, 0x80, 0);
   /*
    * Set parity, stop bits and data bits
    */
   set_port(port + 3, 0xFF, ((ttp->parity & 7) << 3)
                     | (((ttp->stop_bits - 1) & 1) << 2)
                     | ((ttp->data_bits - 5) & 3) );

   if(init) {
      /*
       * Save initial modem status, and also clear all interrupts
       */
      outp(port + 1, 0x00);   /* Disable all interrupts */
      inp(port + 5); /* Clear Line Status Interrupt */
      inp(port + 0); /* Clear RX Interrupt */
      inp(port + 2); /* Clear TX Interrupt */
      ttp->modem_status = inp(port + 6) & 0xF0; /* Clear Modem Interrupt */
      /*
       * turn on DTR, RTS
       */
      outp(port+4, ttp->modem_control);

      switch(ttp->threshold) {
         case 1:  value = 0x01; break;
         case 4:  value = 0x41; break;
         case 8:  value = 0x81; break;
         case 14: value = 0xC1; break;
         default: value = 0; break;
         }

      if(value) {
         /*
          * Try to enable 1/4/8/14-deep FIFO mode if a 16550
          * NOTE: That this is NOT always desirable since it significantly
          *       affects recieved character timing, and does NOT
          *       significantly increase receive performance.
          *       (Keep in mind that the 16550 with FIFO disabled
          *        is still very useful, since it SHOULD buffer
          *        up to 16 received characters even when FIFO is off)
          */
         outp(port+2, value);
         if((inp(port+2) & 0xC0) != 0xC0)
            outp(port+2, 0x00);                 
         }
      /*
       * Enable ALL interrupt sources
       */
      outp(port+1, 0x0f);

      if((ttp->mode & MODE_IRQ_LINKED) == 0) {
         ttp->mode |= MODE_IRQ_LINKED;
         /*
          * Add this device to the list of devices at the specified interrupt
          */
         ttp->link = dev_list[ttp->irq];
         dev_list[ttp->irq] = ttp;
      
         if(int_enabled[ttp->irq] == 0) {
            /*
             * Vector IRQ to our async handler
             */
            _enable();
            irq_hdl[ttp->irq] = qnx_hint_attach(ttp->irq, async_irq[ttp->irq], FP_SEG(&drv_ctrl));
            int_enabled[ttp->irq] = 1;
            }
         }
      }

   _enable();

   return(0);
   }

void disable_irq( int index )
   {
   register struct dev_entry *ttp, *tt;
   int irq;

   ttp = &dev_table[index];
   irq = ttp->irq;

   if((ttp->mode & MODE_IRQ_LINKED) != 0) {
      ttp->mode &= ~MODE_IRQ_LINKED;
      /*
       * Remove this device from list of devices at the specified interrupt
       */
      tt = (struct dev_entry *) &dev_list[irq];
      while(tt) {
         if(tt->link == ttp) {
            tt->link = ttp->link;
            ttp->link = 0;
            break;
            }
         }
      
      if(dev_list[irq] == 0) {
         /*
          * IRQ list is now empty
          */
         int_enabled[irq] = 0;
         qnx_hint_detach(irq_hdl[irq]);
         }
      }
   }

pid_t far poll_devices() {
   int i;
   struct dev_entry *dev = &dev_table[0];

   for( i = 0; i < num_asyncs; ++i) {
      if(dev->iobase != 0  &&  dev->tx_pending != 0  &&  --dev->tx_pending == 0) {
         /*
          * Compensate for "bugs" (especially CMOS parts) which cause 
          * missed Tx interrupts.
          * Rely on periodic "polling" to reset the chip.
          */
         outp(dev->iobase+1, 0x0f);
         Trace1( (long)_TRACE_DEV_SER_TIMEOUT, _TRACE_TRANSIENT, dev->iobase );
         }
      ++dev;
      }
   return(0);
   }

/*
 * If -w is specified, then Dev.ser will disable interrupts
 * on the serial chip when SIGPWR is received (soft reboot)
 */

shutdown_async(int index) {
   unsigned iobase;

   iobase = dev_table[index].iobase;
   if(iobase != 0)
      outp(iobase + 1, 0x00); /* Disable IER */
   }

#pragma on (check_stack);

---