txproc.c

marvell8385 GSPI开发驱动

		if ( pTQNode == NULL ) {
			///crlo:test ++
			///crlo: queue is full. Leave now, instead of sending the packet
			DBGPRINT(DBG_TXDATA, ("pq: 3\n") );
RETAILMSG(1,(L"Exit: %s, queue is full, LeaveCriticalSection \n", TEXT(__FUNCTION__))); 
			LeaveCriticalSection(&Adapter->TxCriticalSection);   
			return NDIS_STATUS_FAILURE;
			///crlo:test --
		}
// tt --

              pPacket = pTQNode -> pPacket; 
              if(pPacket)
              {
                  Status = SendSinglePacket(Adapter,pPacket);
                  if(Status == NDIS_STATUS_SUCCESS)
                  {       
                      PushFreeTxQNode(Adapter->TxFreeQ,pTQNode);  
                      Adapter->TxPacketCount--;
                  }
                  else
                  {  
                      RETAILMSG(1,(TEXT("[TxDone] Send packet fail\r\n")));
              
                      //Error handling , push back this node 
                      InsertTxQNodeFromHead(pTxQKeeper,pTQNode); 
                  } 
              }
              else
                    RETAILMSG(1,(TEXT("severe error, Get NULL packet...\n\r")));
//            } //curr_cmd
          }
 
        LeaveCriticalSection(&Adapter->TxCriticalSection);   

#if 1
#ifdef NEW_PS_SCHEME   //dralee,072705
          //if ( Adapter->psState == PS_STATE_SLEEP_PENDING )
          if ( Adapter->psState == PS_STATE_SLEEP && Adapter->bPSConfirm==FALSE )
          {                     
              //RETAILMSG(1,(TEXT("\n\rTx_Done: PS_STATE_SLEEP_PENDING")));
              // check the OS sent another packet, if not, then send
              // sleep confirm  
            #ifdef HOST_SLEEP_PS     
            if( Adapter->HostPowerState == HTWK_STATE_FULL_POWER || 
                Adapter->HostPowerState == HTWK_STATE_SLEEP )
            {
                if( Adapter->SentPacket == NULL &&   
                    Adapter->CurCmd == NULL )  
                PSConfirmSleep(Adapter); 
#ifdef CONFIG_WLAN_PMU
		wlan_PMUSleepConfirmed();
#endif			
                //PSConfirmSleep(Adapter); 
                
                //MrvPrintFile("\nPS_confirmed at txdone");
              

                RETAILMSG(1,(TEXT("PS_Confirm: in Txsingledone\n\r")));
            }
            #else
            if (Adapter->PSCurCmd == NULL )
            {  
               PSConfirmSleep(Adapter); 
#ifdef CONFIG_WLAN_PMU
		wlan_PMUSleepConfirmed();
#endif			
               RETAILMSG(1,(TEXT("PS_Confirm: in Txsingledone\n\r")));
            }
            #endif  
          }
#endif  
#endif   

  return NDIS_STATUS_SUCCESS;
} 


/******************************************************************************
 *
 *  Name: AllocateSingleTx()
 *
 *  Description: Allocate single Tx 
 *
 *  Arguments:  PMRVDRV_ADAPTER Adapter
 *    
 *  Return Value: NDIS_STATUS_SUCCESS or NDIS_STATUS_FAILURE
 * 
 *  Notes:        
 *
 *****************************************************************************/
 
NDIS_STATUS AllocateSingleTx(
  IN PMRVDRV_ADAPTER Adapter
  )
{
  Adapter->TxNode.BufVirtualAddr = NULL;
  Adapter->TxNode.BufPhyAddr.LowPart = 0xffffffff;
  Adapter->TxNode.BufPhyAddr.HighPart = 0xffffffff;
  Adapter->TxNode.LocalWCB = &Adapter->Wcb;
  Adapter->TxNode.Status = MRVDRV_TX_CTRL_NODE_STATUS_IDLE;
  Adapter->Wcb.PktPtr = 0xffffffff;


    return NDIS_STATUS_SUCCESS;
}

VOID FreeSingleTx(
  IN PMRVDRV_ADAPTER Adapter
  )
{
    return;
}
                    
#ifdef TX_PRY_Q
VOID InitializeTxNodeQ(IN PMRVDRV_ADAPTER Adapter )
{   
   int i; 
                             
   Adapter->TxFreeQ = (PTXQ_NODE)&Adapter->FreeTxQNode[0];
   for(i=0; i<MAX_TX_PACKETS-1; i++)
      Adapter->FreeTxQNode[i].next = (PTXQ_NODE)&Adapter->FreeTxQNode[i+1];

   Adapter->FreeTxQNode[MAX_TX_PACKETS-1].next = NULL; 
}
#endif



/******************************************************************************
 *
 *  Name: CleanUpSingleTxBuffer()
 *
 *  Description: Clean up single Tx Bbuffer
 *
 *  Arguments:  PMRVDRV_ADAPTER Adapter
 *    
 *  Return Value: NDIS_STATUS_SUCCESS or NDIS_STATUS_FAILURE
 * 
 *  Notes:        
 *
 *****************************************************************************/
NDIS_STATUS
CleanUpSingleTxBuffer(
IN PMRVDRV_ADAPTER Adapter
)
{      
    ULONG i;
    BOOLEAN timerStatus;
    PNDIS_PACKET pPacket;

             
    RETAILMSG(1,(TEXT("[Marvell]+CleanUpSingleTxBuffer()"))); 

    if(Adapter->TxPktTimerIsSet==TRUE)
    {   
       NdisMCancelTimer(&Adapter->MrvDrvTxPktTimer, &timerStatus); 
       Adapter->TxPktTimerIsSet=FALSE;
    }
    //dralee
    //tt ra fail: Dragon suggested 2005/10/17
    EnterCriticalSection(&Adapter->TxCriticalSection);
             
    #ifdef TX_PRY_Q    
    if( Adapter->SentPacket )
    {           
        pPacket = Adapter->SentPacket;
        Adapter->SentPacket = NULL;
        
        //dralee 20051031++
        if( Adapter->bSentPacketReturned == 0 ) 
        {
            NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_FAILURE);
            NdisMSendComplete(
                              Adapter->MrvDrvAdapterHdl, 
                              pPacket, 
                              NDIS_STATUS_FAILURE);    
        }
        else
            Adapter->bSentPacketReturned = 0;
        //dralee++
    }
    for(i=0; i< MAX_TX_PACKETS; i++)
    {
        PTXQ_KEEPER  pTxQKeeper;
        PTXQ_NODE    pTQNode;

        TxPacketDeQueue(Adapter, &pTxQKeeper, &pTQNode);
        if(pTQNode == NULL)
           break; 
        pPacket = pTQNode -> pPacket;  

//tt ++ ra fail
		if ( pPacket == NULL )
			V5DbgMsg( (L"   ??? nul pkt\n") );

		if ( pPacket )
		{
//tt --
        NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_FAILURE);
        NdisMSendComplete(
                           Adapter->MrvDrvAdapterHdl, 
                           pPacket, 
                           NDIS_STATUS_FAILURE);    
		} //tt ra fail

//tt ++ ra fail
		// Dragon suggested 2005/10/17
		PushFreeTxQNode( Adapter->TxFreeQ, pTQNode );
//tt --
    } 
//tt ++ ra fail

#ifdef RETQ_TIMER
        if( Adapter->RetQTimerIsSet)
        {              
            Adapter->RetQTimerIsSet = 0;
            NdisMCancelTimer(&Adapter->MrvRetQTimer, &timerStatus); 
   	      	BatchIndicateRetQPkts(Adapter);
        }
#endif


//tt --
    InitializeTxNodeQ(Adapter); 

    #else
    for(i=0; i< MAX_TX_PACKETS; i++)
    {   
       pPacket = Adapter->SendPackets[i];

       if( pPacket )
       {           
          Adapter->SendPackets[i] = NULL;

          NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_FAILURE);
          NdisMSendComplete(
                           Adapter->MrvDrvAdapterHdl, 
                           pPacket, 
                           NDIS_STATUS_FAILURE);   
       }   
    }
    #endif 

    //set Tx queue parameter to default 
    Adapter->TxPacketCount=0;
    Adapter->TxPacketComplete = 0;
    Adapter->TxPacketPut = 0;
    Adapter->TxPacketGet = 0; 
    Adapter->SentPacket = NULL;
    
    //dralee
    //tt ra fail: Dragon suggested 2005/10/17
    LeaveCriticalSection(&Adapter->TxCriticalSection); 

    return NDIS_STATUS_SUCCESS;
}
 
 

/******************************************************************************
 *
 *  Name: MrvDrvCancelSendPacket()
 *
 *  Description: Miniport Tx pakcet cancellation routine
 *
 *  Conditions for Use:
 *
 *  Arguments:
 *      IN  NDIS_HANDLE MiniportAdapterContext,
 *      IN  PVOID       GroupCancelId
 *    
 *  Return Value: None
 * 
 *  Notes:               
 *
 *****************************************************************************/
#ifdef MRVL_WINXP_NDIS51 
#ifndef TX_PRY_Q
VOID
MrvDrvCancelSendPackets(
  IN  NDIS_HANDLE MiniportAdapterContext,
    IN  PVOID       GroupCancelId
  )
{
    //NDIS_STATUS curStatus;
  PMRVDRV_ADAPTER Adapter;
   // NDIS_STATUS Status;
  PVOID CurCancelId;
  PNDIS_PACKET   pPacket; 

  DBGPRINT(DBG_TXDATA,("TX - Enter MrvDrvCancelSendPackets \n"));
  RETAILMSG(1,(TEXT("[Marvell]+MrvDrvCancelSendPackets")));
  Adapter = (PMRVDRV_ADAPTER)MiniportAdapterContext;  

  EnterCriticalSection(&Adapter->TxCriticalSection);

  while( Adapter->TxPacketCount )
  {
       pPacket = Adapter->SendPackets[Adapter->TxPacketComplete];  

//tt ++ ra fail
		if ( pPacket == NULL )
			V5DbgMsg( (L"   ??? nul pkt (cancel send)\n") );
//tt --
       CurCancelId = NDIS_GET_PACKET_CANCEL_ID(pPacket);
       if( CurCancelId == GroupCancelId )
       {
          NdisMSendComplete(
                           Adapter->MrvDrvAdapterHdl, 
                           pPacket, 
                           NDIS_STATUS_REQUEST_ABORTED);   

          Adapter->SendPackets[Adapter->TxPacketComplete] = NULL;
       }  
 
       Adapter->TxPacketCount--;
       Adapter->TxPacketComplete = ++Adapter->TxPacketComplete % MAX_TX_PACKETS;
  }

  //set Tx queue parameter to default 
  Adapter->TxPacketCount=0;
  Adapter->TxPacketComplete = 0;
  Adapter->TxPacketPut = 0;
  Adapter->TxPacketGet = 0; 
  Adapter->SentPacket = NULL;

  LeaveCriticalSection(&Adapter->TxCriticalSection); 

/* dralee -------

    //-----------------------------------------------------------------------------
    // PJG: If queing then cancel any in the group that are in our queue
    //-----------------------------------------------------------------------------
  //      Get CurCancelId
    if(Adapter->SentPacket)
    {
        CurCancelId = NDIS_GET_PACKET_CANCEL_ID(Adapter->SentPacket);
      if( CurCancelId == GroupCancelId )
      {
          //RETAILMSG(1,(TEXT("[Marvell]MrvDrvCancelSendPackets:1 Cancel the current packet")));
        //      Cancel the current packet
        NdisMSendComplete(Adapter->MrvDrvAdapterHdl, Adapter->SentPacket, NDIS_STATUS_REQUEST_ABORTED);
              Adapter->SentPacket = NULL;
        //RETAILMSG(1,(TEXT("[Marvell]MrvDrvCancelSendPackets:2 Cancel the current packet")));  
        }
    }
           
  #ifndef CHECK_LATER
  if(Adapter->QueuedPacket)
    {
        CurCancelId = NDIS_GET_PACKET_CANCEL_ID(Adapter->QueuedPacket);
      if( CurCancelId == GroupCancelId )
      {
         //RETAILMSG(1,(TEXT("[Marvell]MrvDrvCancelSendPackets:1 Cancel the queue packet"))); 
        // Cancel the queue packet
        NdisMSendComplete(Adapter->MrvDrvAdapterHdl, Adapter->QueuedPacket, NDIS_STATUS_REQUEST_ABORTED);
            Adapter->QueuedPacket = NULL;
     // RETAILMSG(1,(TEXT("[Marvell]MrvDrvCancelSendPackets:2 Cancel the queue packet")));    
        }
    }
  #endif
  //RETAILMSG(1,(TEXT("[Marvell]-MrvDrvCancelSendPackets"))); 

*/

  return;
}  
#endif //TX_PRY_Q
#endif


#ifdef USE_TX_QUEUE
/******************************************************************************
 *
 *  Name: MrvDrvCancelSendPacket()
 *
 *  Description: Miniport Tx pakcet cancellation routine
 *
 *  Conditions for Use:
 *
 *  Arguments:
 *      IN  NDIS_HANDLE MiniportAdapterContext,
 *      IN  PVOID       GroupCancelId
 *    
 *  Return Value: None
 * 
 *  Notes:               
 *
 *****************************************************************************/
VOID
MrvDrvSendPackets(
  IN  PMRVDRV_ADAPTER         Adapter,
  IN  PPNDIS_PACKET           PacketArray,
  IN  UINT                    NumberOfPackets
  )
{
  return; 
}
#endif // #ifdef USE_TX_QUEUE 

#ifdef TX_PRY_Q   

VOID TxPacketEnQueue(PMRVDRV_ADAPTER Adapter,PNDIS_PACKET Packet)
{                       
  PTXQ_KEEPER  pTxQKeeper;
  PTXQ_NODE    pTQNode;
  int          priority;
  
  #ifdef TX_PRY_Q_TEST
  priority = GetTickCount()&0x3;
  #else
  priority = 3; 
  #endif 

  pTQNode = PopFreeTxQNode(Adapter->TxFreeQ);
  pTQNode->pPacket = Packet;    

  //RETAILMSG(1,(L"Enqueue: %x, %x\n\r",(ULONG)pTQNode,(ULONG)Packet));

  //Adapter->TxPacketCount++;
  //Adapter->TxPacketSend++;  

  pTxQKeeper = (PTXQ_KEEPER)&Adapter->TXPRYQ[priority];
  InsertTxQNodeAtTail(pTxQKeeper,pTQNode); 
 
}


VOID TxPacketDeQueue(PMRVDRV_ADAPTER Adapter,PPTXQ_KEEPER ppTxQKeeper,PPTXQ_NODE ppTQNode)
{ 
    int pri;

    for(pri=0; pri<4; pri++)
    {
       *ppTxQKeeper = (PTXQ_KEEPER)&Adapter->TXPRYQ[pri];
       *ppTQNode = PopFirstTxQNode(*ppTxQKeeper);
       if(*ppTQNode)
          break;
    }   

    //RETAILMSG(1,(L"Dequeue:%x, %x\n\r",(ULONG)(*ppTQNode),(ULONG)((*ppTQNode)->pPacket)));
    /*
    if( *ppTQNode )
      return NDIS_STATUS_SUCCESS;
    else 
      return NDIS_STATUS_FAILURE;
    */
}




#endif