profim.c

profibus-dp主站源代码

              }
              if ( DeviceExtension->RTL==0 )
              {
                DeviceExtension->ContinueFrame = FALSE;
                DeviceExtension->RTL = 3;
              }
            }
            
            u950pci_RxTreshold( DeviceExtension , DeviceExtension->RTL );
          
          #else // USE_RX_FIFO **************************************
          
            //
            // Read the UART receive register
            //
            ch = u950pci_inb( DeviceExtension->port, UART_RX );

            if ( DeviceExtension->Sending == FALSE ||
                 ( DeviceExtension->Sending == TRUE &&
                   DeviceExtension->ActualType != DATA_CHAR ) )  // prijaty znak je z vnejsku
            {
              PB_RxByte( &( DeviceExtension->PB ), ch );            
            }
            else
            {
              // prijaty znak je z HW loopbacku prevodniku
              // melo by se jednat pouze o znovu prijate DATA_CHAR
              // zahazujeme...            
              DeviceExtension->RXCountDown--;
            }
            
          #endif // USE_RX_FIFO *************************************
        
          break;

          
        //*********************************************************************                                      
        // Transmitter holding register empty
        //*********************************************************************                                              
        case UART_IIR_THRI:        
        
          switch ( DeviceExtension->ActualType )
          {
            case DATA_CHAR:
              DeviceExtension->FlushTCH = FALSE;
              //RS_DbgPrint ("ISR TX DATA_CHAR \n"); 
              if ( ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                     DATA_CHAR ) &&
                   !AllSent( DeviceExtension ) )
              {
                // next byte out                                     
                //DbgPrint( "Vysilany znak = %x\n", DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] );                                   
                FillTxBuffer( DeviceExtension );                
              }             
              else
              {
                // drive v DPC
                
                //
                // Switch to receive
                //
                #ifdef AUTOMATIC_RX
                  // Disable automatic DTR control
                  u950pci_acr_write( DeviceExtension, U950PCI_RX_ACR( DeviceExtension) );
                #else
                  u950pci_outb( DeviceExtension->port, UART_MCR, U950PCI_RX_MCR( DeviceExtension ) );
                #endif
                

                if ( AllSent( DeviceExtension ) )
                {
                  // Stahnout priznak vysilani
                  DeviceExtension->Sending = FALSE;

                  // Oznamime Profibusu kompletni zpracovani vysilaciho bufferu
                  PB_FrameOut( &( DeviceExtension->PB ) );
                }
                else
                {
                  Jam_First_Out( DeviceExtension );
                }               
              }
              break;


            case TIMING_CHAR:
              //RS_DbgPrint ("ISR TX TIMING_CHAR \n");          
              if ( DeviceExtension->FlushTCH == TRUE )
              {
                while ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                        TIMING_CHAR &&
                        DeviceExtension->XmitFirst !=
                        DeviceExtension->XmitLast )
                {
                  DeviceExtension->XmitFirst++;
                  if ( DeviceExtension->XmitFirst >= DeviceExtension->BufferSize )
                    DeviceExtension->XmitFirst = 0;
                }                            
                DeviceExtension->FlushTCH = FALSE;                   
                //break;
              }

              if ( ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                     TIMING_CHAR ) &&
                   !AllSent( DeviceExtension ) )
              {
                // next byte out                                                        
                //DbgPrint( "Vysilany znak = %x\n", DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] );
                FillTxBuffer( DeviceExtension );              
              }
              else
              {                
                // drive v DPC
                
                PB_TimeTick( &( DeviceExtension->PB ) );                                
                
                if ( AllSent( DeviceExtension ) )
                {
                  DeviceExtension->Sending = FALSE;
                }
                else
                {
                  Jam_First_Out( DeviceExtension );
                }   
                DeviceExtension->FlushTCH = FALSE;                

              }       
              break;


            case SYN_CHAR:
              DeviceExtension->FlushTCH = FALSE;
              //RS_DbgPrint ("ISR TX SYN_CHAR \n");                         
              if ( ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                     SYN_CHAR ) &&
                   !AllSent( DeviceExtension ) )
              {
                // next byte out                     
                //DbgPrint( "Vysilany znak = %x\n", DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] );                                   
                FillTxBuffer( DeviceExtension );
              }
              else
              {
                
                // drive v DPC
                
                if ( AllSent( DeviceExtension ) )
                {
                  DeviceExtension->Sending = FALSE;
                }
                else
                {
                  Jam_First_Out( DeviceExtension );
                }   
                DeviceExtension->FlushTCH = FALSE;

              }               
              break;
          }
          break;
          
      }
      
      ch = u950pci_inb( DeviceExtension->port, UART_IIR );    // Read the IIR again for the next loop      
    }
    
  DeviceExtension->InterruptRunning = FALSE;      /*DEBUG*/
  if (DeviceExtension->SecondInterrupt) {
    DeviceExtension->SecondInterrupt = FALSE;
    //DbgPrint("ProfiM - ukonceni prerusene obsluhy preruseni...");
  }
  
  
  /*DEBUG*/  
  //u950pci_outb( DeviceExtension->port, UART_IER, 
  //              UART_IER_RDI | UART_IER_THRI | UART_IER_RLSI );   // Enable Interrupts

            
  }
  //*******************************************************  
  //  ISR for standard COM
  //*******************************************************    
  else
  {    
    
    //
    // For the 8250 series UART, we must spin and handle ALL interrupts
    // before returning
    //

    ch = READ_PORT_UCHAR( DeviceExtension->ComPort.IIR );
    
    //
    // Je preruseni pro nas?
    //
    if ( ch & IIR_NO_INTERRUPT_PENDING )
      return FALSE;
      
    if ( !DeviceExtension->PB.AllInitialized )
      return TRUE;   
    

    while ( ( ch & IIR_INTERRUPT_MASK ) != IIR_NO_INTERRUPT_PENDING )
    {
      switch ( ch & IIR_INTERRUPT_MASK )
      {
        //*********************************************************************
        //  8250 Error 
        //*********************************************************************
        case IIR_RX_ERROR_IRQ_PENDING:
          // 1st priority interrupt
          ch = READ_PORT_UCHAR( DeviceExtension->ComPort.LSR );
          DbgPrint( "ProfiM: ISR RX Error!  LSR=%x\n", ch );                
          DeviceExtension->RcvError++;

          if ( DeviceExtension->Sending )
          {
            // Switch to receive
            ch = READ_PORT_UCHAR( DeviceExtension->ComPort.MCR ) & MCR_DEACTIVATE_RTS;
            WRITE_PORT_UCHAR( DeviceExtension->ComPort.MCR, ch );               

            DeviceExtension->Sending = FALSE;
            DeviceExtension->XmitFirst = DeviceExtension->XmitLast;   // vymazani celeho bufferu
            PB_FrameOut( &( DeviceExtension->PB ) );
          }

          break;



        //*********************************************************************
        //  Data received
        //*********************************************************************
        case IIR_RX_DATA_READY_IRQ_PENDING:
          // 2nd priority int

          //
          // Read the UART receive register
          //

          ch = READ_PORT_UCHAR( DeviceExtension->ComPort.RBR );

          if ( DeviceExtension->Sending == FALSE ||
               ( DeviceExtension->Sending == TRUE &&
                 DeviceExtension->ActualType != DATA_CHAR ) )  // prijaty znak je z vnejsku
          {
            PB_RxByte( &( DeviceExtension->PB ), ch );
          }
          else
          {
            // prijaty znak je z HW loopbacku prevodniku - melo by se jednat pouze o znovu prijate DATA_CHAR

            //RS_DbgPrint ("ProfiM: ISR RX data loopback\n");

            DeviceExtension->RXCountDown--;

            if ( DeviceExtension->RXCountDown <= 0 ) // vsechny znaky byly vyslany - konec vysilani - stahnout RTS
            {
              //
              // Switch to receive
              //

              ch = READ_PORT_UCHAR( DeviceExtension->ComPort.MCR ) & MCR_DEACTIVATE_RTS;
              WRITE_PORT_UCHAR( DeviceExtension->ComPort.MCR, ch );               

              //RS_DbgPrint ("ProfiM: RTS lowered\n");

              if ( AllSent( DeviceExtension ) )
              {
                // Stahnout priznak vysilani
                DeviceExtension->Sending = FALSE;

                // Oznamime Profibusu kompletni zpracovani vysilaciho bufferu
                PB_FrameOut( &( DeviceExtension->PB ) );
              }
              else
              {
                Jam_First_Out( DeviceExtension );
              }
            }                
            // else  zahodime prijaty znak
          }

          //
          // Get the current system time
          //

          //KeQuerySystemTime (&DeviceExtension->LastQuerySystemTime);

          break;



        //*********************************************************************   
        // Tx Register Empty    
        //*********************************************************************
        case IIR_TX_HBE_IRQ_PENDING:
          // 3rd priority interrupt

          //RS_DbgPrint ("ProfiM: ISR TX Data!\n");


          switch ( DeviceExtension->ActualType )
          {
            case DATA_CHAR:
              DeviceExtension->FlushTCH = FALSE;
              //RS_DbgPrint ("ISR TX DATA_CHAR \n"); 
              if ( ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                     DATA_CHAR ) &&
                   !AllSent( DeviceExtension ) )
              {
                //              DbgPrint ("Dalsi datovy byte ven : %d\n",DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] ); 
                // next byte out                                                        
                WRITE_PORT_UCHAR( DeviceExtension->ComPort.TBR,
                                  DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] );

                DeviceExtension->XmitFirst++;
                if ( DeviceExtension->XmitFirst >= DeviceExtension->BufferSize )
                  DeviceExtension->XmitFirst = 0;
              }             
              break;


            case TIMING_CHAR:
              //RS_DbgPrint ("ISR TX TIMING_CHAR \n");          
              if ( DeviceExtension->FlushTCH == TRUE )
              {
                while ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                        TIMING_CHAR &&
                        DeviceExtension->XmitFirst !=
                        DeviceExtension->XmitLast )
                {
                  DeviceExtension->XmitFirst++;
                  if ( DeviceExtension->XmitFirst >= DeviceExtension->BufferSize )
                    DeviceExtension->XmitFirst = 0;
                }            
                DeviceExtension->FlushTCH = FALSE;   
                //break;  // nemuze tady byt musi se pockat na konec znaku
              }

              if ( ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                     TIMING_CHAR ) &&
                   !AllSent( DeviceExtension ) )
              {
                // next byte out                                                        
                WRITE_PORT_UCHAR( DeviceExtension->ComPort.TBR,
                                  DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] );

                DeviceExtension->XmitFirst++;
                if ( DeviceExtension->XmitFirst >= DeviceExtension->BufferSize )
                  DeviceExtension->XmitFirst = 0;
              }
              else
              {
                #ifndef PISA_IO
                //
                // Schedule the DPC
                //
                //DbgPrint ("ISR TX TIMING_CHAR DPC Scheduled\n");                                                          
                IoRequestDpc( DeviceObject, DeviceObject->CurrentIrp, NULL );             
                #endif

                #ifdef PISA_IO
                //
                // povoleni preruseni od signalu modemu v DPC
                //
                if ( DeviceExtension->ModemInterruptState == MI_Disabled )
                {
                  DeviceExtension->MIEnabledTime = GetCurrentTicks();
                  IoRequestDpc( DeviceObject, DeviceObject->CurrentIrp, NULL );
                }                           
                #endif                        
              }       
              break;


            case SYN_CHAR:
              DeviceExtension->FlushTCH = FALSE;
              //RS_DbgPrint ("ISR TX SYN_CHAR \n");                         
              if ( ( DeviceExtension->XmitTypeBuffer[DeviceExtension->XmitFirst] ==
                     SYN_CHAR ) &&
                   !AllSent( DeviceExtension ) )
              {
                // next byte out                                                        
                WRITE_PORT_UCHAR( DeviceExtension->ComPort.TBR,
                                  DeviceExtension->XmitBuffer[DeviceExtension->XmitFirst] );

                DeviceExtension->XmitFirst++;
                if ( DeviceExtension->XmitFirst >= DeviceExtension->BufferSize )
                  DeviceExtension->XmitFirst = 0;
              }
              else
              {