vc.c

网络驱动开发

           //  Setup the necessary parameters for CBR Schedule table.
           //
           pVc->CbrNumOfEntris = NumOfEntries;
           pVc->CbrPreScaleVal = (UCHAR)PreScaleVal;
           pAdapter->TotalEntriesUsedonCBRs += NumOfEntries;

                      
#if    AW_QOS

           //
           //	The Number of available CBR VCs
           //  9/17/97     - Please read the note where declares this
           //                variable (in SW.H).
           //	
           pAdapter->NumOfAvailableCbrVc--;

#endif // end of AW_QOS

       }                                            

       //
       //	Pre build a Toshiba ATM155 PCI transmit slot descriptor.
       //
       pXmitSegInfo->InitXmitSlotDesc.reg = 0;
       pXmitSegInfo->InitXmitSlotDesc.VC = pVc->VpiVci.Vci;

     	//
       //	Save the flow parameters that we were registered with.
       //
       pVc->Transmit = *pXmitFlow;

       //
       //	Pre build a 155 PCI ATM transmit buffer information block.
       //
       pXmitSegInfo->Adapter = pAdapter;
       pXmitSegInfo->pEntryOfXmitState = 
                       pHwInfo->pSramTxVcStateTbl +
                       (pVc->VpiVci.Vci * SIZEOF_TX_STATE_ENTRY);

       pXmitState = &pXmitSegInfo->InitXmitState;

       NdisZeroMemory (
           (PVOID)(pXmitState),
           sizeof(TBATM155_TX_STATE_ENTRY));

	    switch (pXmitFlow->ServiceCategory) {

           case ATM_SERVICE_CATEGORY_CBR:
               pXmitState->TxStateWord0.RC = TX_STAT_RC_CBR;
               pXmitState->TxStateWord0.prescal_val = (USHORT)PreScaleVal;
		        DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
                   ("ATM_SERVICE_CATEGORY_CBR\n"));
               break;

           case ATM_SERVICE_CATEGORY_UBR:
               pXmitState->TxStateWord0.RC = TX_STAT_RC_UBR;
		        DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
                   ("ATM_SERVICE_CATEGORY_UBR\n"));
               break;

           case ATM_SERVICE_CATEGORY_ABR:

//=================================
#if    ABR_CODE
//=================================

               //
               // Set to ABR parameter base set 1 always for now.
               //
               pXmitState->TxStateWord0.ABS = 0;
               pXmitState->TxStateWord0.RC = TX_STAT_RC_ABR;

//=================================
#else     // not ABR_CODE
//=================================

               pXmitState->TxStateWord0.RC = TX_STAT_RC_UBR;

//=================================
#endif     // end of ABR_CODE
//=================================

		        DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
                   ("ATM_SERVICE_CATEGORY_ABR\n"));
               break;

           default:
               Status = NDIS_STATUS_INVALID_DATA;
               break;
       }

       if (NDIS_STATUS_SUCCESS != Status) {
		    DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
               ("Invalid Service Category for VC: 0x%x\n", pVc));
           break;
       }
           
       if (pAtmMediaParms->AALType == AAL_TYPE_AAL5)
       {
           pXmitState->TxStateWord0.chtype = TX_STAT_CHTYPE_AAL5;
       }
       else
       {
           pXmitState->TxStateWord0.chtype = TX_STAT_CHTYPE_RAW;
       }
       pXmitState->TxStateWord2.tx_AAL5_CRC_Low  = 0x0FFFF;
       pXmitState->TxStateWord3.tx_AAL5_CRC_High = 0x0FFFF;

       if (pAtmMediaParms->DefaultCLP == 1)
       {
           pXmitState->TxStateWord0.CLP = 1;
       }
       else
       {
           pXmitState->TxStateWord0.CLP = 0;
       }

	    //
	    //	Do we need to complete the packet when it is done being
	    //	segmented or can we do it early?
	    //  
	    if ((pMediaParameters->Flags & INDICATE_END_OF_TX) == INDICATE_END_OF_TX)
	    {
		    VC_SET_FLAG(pVc, fVC_INDICATE_END_OF_TX);
	    }


	    //
	    //	Initialize the queues for packets waiting for segmentation and
	    //	packets waiting for transmit.
	    //
       DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO, ("InitializePacketQueue\n"));
	    tbAtm155InitializePacketQueue(&pXmitSegInfo->SegWait);

       //
       //  Allocate the buffers for transmission.
       //
       DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO, ("AllocateTransmitBuffers\n"));
       Status = tbAtm155AllocateTransmitBuffers(pVc);

       //
       // NdisMAllocateSharedMemoryAsync is used in tbAtm155AllocateTransmitBuffers,
       // so we need to handle NDIS_STATUS_PENDING.
       //

       if (NDIS_STATUS_PENDING != Status)
       {
           DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
               ("Failed of tbAtm155AllocateTransmitBuffers() for VC: 0x%x\n", pVc));
           break;
       }

   } while (FALSE);

   //
   //	If there was a failure then clean up.
   //

   if ((NDIS_STATUS_SUCCESS != Status) && (NDIS_STATUS_PENDING != Status))
   {
       if (NULL != pVc->XmitSegInfo)
       {
           tbAtm155FreeTransmitBuffers(pAdapter, pVc);

           FREE_MEMORY(pVc->XmitSegInfo, sizeof(XMIT_SEG_INFO));
           pVc->XmitSegInfo = NULL;
       }
   }

   DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
       ("<==tbAtm155AllocateTransmitSegment (Status: 0x%lx)\n", Status));

   return(Status);
}


NDIS_STATUS
tbAtm155ValidateVpiVci(
   IN  PADAPTER_BLOCK          pAdapter,
   IN  PATM_MEDIA_PARAMETERS   pAtmMediaParms
   )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
   PHARDWARE_INFO  pHwInfo = pAdapter->HardwareInfo;
   PVC_BLOCK       pCurrentVc;
   BOOLEAN         fInvalidVc = FALSE;
   PLIST_ENTRY     Link;
   //
   //	We only support VPI of 0!
   //
   if (pAtmMediaParms->ConnectionId.Vpi != 0)
   {
       return(NDIS_STATUS_FAILURE);
   }

   if ((pAtmMediaParms->ConnectionId.Vci > (ULONG)(pHwInfo->NumOfVCs - 1)))
   {
		DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
           ("<==tbAtm155ValidateVpiVci (NDIS_STATUS_FAILURE)\n"));

       return(NDIS_STATUS_FAILURE);
   }

   //
   //	See if we have a VC with the given VPI/VCI
   //
   Link = pAdapter->ActiveVcList.Flink;
   while (Link != &pAdapter->ActiveVcList)
   {
       pCurrentVc = CONTAINING_RECORD(Link, VC_BLOCK, Link);
       if ((pCurrentVc->VpiVci.Vpi == pAtmMediaParms->ConnectionId.Vpi) &&
           (pCurrentVc->VpiVci.Vci == pAtmMediaParms->ConnectionId.Vci))
       {
           fInvalidVc = TRUE;
           break;
       }
       
       Link = Link->Flink;
       
   }

   //
   //	Did we find a VC with the given VPI/VCI.
   //
   if (fInvalidVc)
   {
       return(NDIS_STATUS_FAILURE);
   }

   return(NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
TbAtm155ActivateVc(
   IN      NDIS_HANDLE             MiniportVcContext,
   IN OUT  PCO_CALL_PARAMETERS     CoCallParameters
   )
/*++

Routine Description:

   This is the NDIS 5.0 handler to activate a given VC.  This will allocate
   hardware resources, e.g. QoS, for a VC that was already created.

Arguments:

   MiniportVcContext   -   Pointer to the VC_BLOCK representing the VC to
                           activate.
   MediaParameters     -   ATM parameters (in our case) that are used to
                           describe the VC.

Return Value:

   NDIS_STATUS_SUCCESS	    if the VC is successfully activated.

--*/
{
   PVC_BLOCK               pVc = (PVC_BLOCK)MiniportVcContext;
   PADAPTER_BLOCK          pAdapter = pVc->Adapter;
   PATM_MEDIA_PARAMETERS   pAtmMediaParms;
   NDIS_STATUS             Status = NDIS_STATUS_SUCCESS;
   PCO_MEDIA_PARAMETERS    pMediaParameters;

   DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
       ("==>TbAtm155ActivateVc\n"));

   NdisAcquireSpinLock(&pAdapter->lock);

   //
   //	If the adapter is resetting then refuse to do this.
   //
   if (ADAPTER_TEST_FLAG(pAdapter, fADAPTER_RESET_REQUESTED) ||
       ADAPTER_TEST_FLAG(pAdapter, fADAPTER_RESET_IN_PROGRESS))
   {
       NdisReleaseSpinLock(&pAdapter->lock);

       return(NDIS_STATUS_RESET_IN_PROGRESS);
   }

   NdisDprAcquireSpinLock(&pVc->lock);

   //
   //	If the VC is already active then we will need to
   //	re-activate the VC with new parameters.....
   //
   if (VC_TEST_FLAG(pVc, fVC_ACTIVE))
   {
       //
       //	Ok, to handle a re-activate we will first deactivate the
       //	vc then activate it with the new parameters.  This will
       //	most likely cause it to pend....
       //
       DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
           ("tbAtm155ActivateVc currently doesn't support re-activation of VCs.\n"));

       DBGBREAK(DBG_COMP_VC, DBG_LEVEL_ERR);

       NdisDprReleaseSpinLock(&pVc->lock);
       NdisReleaseSpinLock(&pAdapter->lock);


       DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
           ("<==TbAtm155ActivateVc (NDIS_STATUS_FAILURE)\n"));

       return(NDIS_STATUS_FAILURE);
   }

   do
   {
       //
       //	Get a convenient pointer to the media parameters.
       //	
       pMediaParameters = CoCallParameters->MediaParameters;

       //
       //	Are there any media specific parameters that we recognize?
       //
       if ((pMediaParameters->MediaSpecific.ParamType != ATM_MEDIA_SPECIFIC) ||
       	(pMediaParameters->MediaSpecific.Length != sizeof(ATM_MEDIA_PARAMETERS)))
       {
           DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
               ("Invalid media parameters for vc creation\n"));

           Status = NDIS_STATUS_INVALID_DATA;

           break;
       }

       //
       //	Get a convenient pointer to the ATM parameters.
       //
       pAtmMediaParms = (PATM_MEDIA_PARAMETERS)pMediaParameters->MediaSpecific.Parameters;

       //
       //	We only handle CBR & UBR VCs.
       //
       if (((pAtmMediaParms->Transmit.ServiceCategory != ATM_SERVICE_CATEGORY_UBR) &&
           (pAtmMediaParms->Transmit.ServiceCategory != ATM_SERVICE_CATEGORY_CBR)) ||
           ((pAtmMediaParms->Receive.ServiceCategory != ATM_SERVICE_CATEGORY_UBR) &&
           (pAtmMediaParms->Receive.ServiceCategory != ATM_SERVICE_CATEGORY_CBR)))
       {
           DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
               ("Invalid service category specified for ActivateVC\n"));

           Status = NDIS_STATUS_INVALID_DATA;

           break;
       }

       //
       //	Validate the VPI/VCI
       //
       Status = tbAtm155ValidateVpiVci(pAdapter, pAtmMediaParms);
       if (NDIS_STATUS_SUCCESS != Status)
       {
           DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
               ("Unable to validate the VCI/VPI\n"));

           break;
       }

       //
       //	Save the VCI with our VC information.
       //
       pVc->VpiVci = pAtmMediaParms->ConnectionId;

       //
       //	Check the AAL type.
       //
       if (pAtmMediaParms->AALType != AAL_TYPE_AAL5)
       {
           Status = NDIS_STATUS_INVALID_DATA;

           DBGPRINT(DBG_COMP_VC, DBG_LEVEL_ERR,
               ("Invalid AAL type (only 5 supported)\n"));

           break;
       }

       //
       //	Save the AAL information with our VC.
       //
       pVc->AALType = pAtmMediaParms->AALType;

       DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
            ("Vc=0x%lx, pMediaParameters->Flags=0x%lx\n",
              pVc->VpiVci.Vci, pMediaParameters->Flags));


#if DBG
              
       //
       //  This debugging code for detecting if there are race 
       //  coditions while activating a VC.
       //
       if ((pMediaParameters->Flags & TRANSMIT_VC) == TRANSMIT_VC)
       {
		    VC_SET_FLAG(pVc, fVC_DBG_TXVC);
       }
       if ((pMediaParameters->Flags & RECEIVE_VC) == RECEIVE_VC)
       {
		    VC_SET_FLAG(pVc, fVC_DBG_RXVC);
       }

#endif // end of DBG


       //
       //	Verify that we can support the given VC parameters.
       //
       if ((pMediaParameters->Flags & TRANSMIT_VC) == TRANSMIT_VC)
       {
           DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
               ("Allocating transmit information for VC\n"));

           //
           //	Allocate transmit resources.
           //
           Status = tbAtm155AllocateTransmitSegment(
                       pAdapter,
                       pVc,
                       pMediaParameters,
                       pAtmMediaParms);

           //
           // Process status NDIS_STATUS_PENDING because
           // NdisMAllocateSharedMemoryAsync is used in 
           // tbAtm155AllocateTransmitBuffers.
           //

           if (NDIS_STATUS_PENDING == Status)
           {
               DBGPRINT(DBG_COMP_VC, DBG_LEVEL_INFO,
                   ("tbAtm155ActivateVc pended!\n"));
               //
               //	Save the CO_CALL_PARAMETERS with the VC for later
               //	completion.
               //
               pVc->CoCallParameters = CoCallParameters;

               VC_SET_FLAG(pVc, fVC_ALLOCATING_TXBUF);
               if ((pMediaParameters->Flags & RECEIVE_VC) != RECEIVE_VC)
               {
                   break;