core_ibcd.c

来自「6440linuxDriver的源代码」· C语言 代码 · 共 1,050 行 · 第 1/3 页

{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;
  struct SMPRequest *pReq;
  MV_U8 i;

  for ( i = 1; i<MAXIMUM_DISCOVER_REQUESTS; i++ )
  {
    if ( pDisc->SMPContext[i].isBufferFree == 1 )
    {
      pDisc->numOfOutstandingReq++;
      pDisc->SMPContext[i].nTgt = nTgt;
      pDisc->SMPContext[i].phyId = PhyId;
      pDisc->SMPContext[i].isBufferFree = 0;

      pReq = (struct SMPRequest*)&pDisc->SMPContext[pDisc->SMPContext[i].BufferIndex].SMPBuffer;

      MV_ZeroMemory ( pReq, sizeof(struct SMPRequest) );

      pReq->Function=DISCOVER;
      pReq->SMPFrameType=SMP_REQUEST_FRAME;
      pReq->Request.Discover.PhyIdentifier=PhyId;

      CORE_IssueSMPRequest ( PortExtension,
                             pDisc->Target[nTgt].Info.SASAddr,
                             (MV_PVOID)pReq,
                             (void (*)(MV_PVOID DiscExtension, 
                                       MV_PVOID PortExtension, 
                                       MV_U8 *SasAddr, 
                                       MV_PVOID pSMPReq))SMP_Callback, 
                             pDISC_Extension );

      break;
    }
  }
}


void Issue_ConfigRouteInfo(
	IN MV_PVOID pDISC_Extension, 
	IN MV_PVOID PortExtension, 
	IN Discover_Target *pParent,
	IN MV_U8 phyId,
	IN MV_U16 nIndex,
	IN MV_U8 *SasAddr
	)
{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;
  struct SMPRequest *pReq;
  MV_U8 i;

  for ( i = 1; i<MAXIMUM_DISCOVER_REQUESTS; i++ )
  {
    if ( pDisc->SMPContext[i].isBufferFree == 1 )
    {
      pDisc->numOfOutstandingReq++;
      pDisc->SMPContext[i].isBufferFree = 0;
      pDisc->SMPContext[i].pDiscExt = pDisc;

      pReq = (struct SMPRequest*)&pDisc->SMPContext[pDisc->SMPContext[i].BufferIndex].SMPBuffer;

      MV_ZeroMemory ( pReq, sizeof(struct SMPRequest) );

      pReq->Function=CONFIGURE_ROUTE_INFORMATION;
      pReq->SMPFrameType=SMP_REQUEST_FRAME;
      pReq->Request.ConfigureRouteInformation.ExpanderRouteIndex[0]=(nIndex&0xff00)>>8;
      pReq->Request.ConfigureRouteInformation.ExpanderRouteIndex[1]=nIndex&0xff;
      pReq->Request.ConfigureRouteInformation.PhyIdentifier=phyId;
      MV_CopyMemory ( pReq->Request.ConfigureRouteInformation.RoutedSASAddress,SasAddr,8 );

      CORE_IssueSMPRequest ( PortExtension,
                             pParent->Info.SASAddr,
                             (MV_PVOID)pReq,
                             (void (*)(MV_PVOID DiscExtension, 
                                       MV_PVOID PortExtension, 
                                       MV_U8 *SasAddr, 
                                       MV_PVOID pSMPReq))SMP_Callback, 
                             (MV_PVOID)&(pDisc->SMPContext[i]) );
      break;
    }
  }
}


void Issue_ReportRouteInfo(
	IN MV_PVOID pDISC_Extension, 
	IN MV_PVOID PortExtension, 
	IN Discover_Target *pParent,
	IN MV_U8 phyId,
	IN MV_U16 nIndex,
	IN MV_U8 *SasAddr
	)
{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;
  /* struct SMPRequest *pReq=(struct SMPRequest*)&pParent->SMPBuffer; */
  /* Report Route always uses Buffer index 0 */
  struct SMPRequest *pReq = (struct SMPRequest*)&pDisc->SMPContext[0].SMPBuffer;

  MV_ZeroMemory ( pReq, sizeof(struct SMPRequest) );
  pReq->Function=REPORT_ROUTE_INFORMATION;
  pReq->SMPFrameType=SMP_REQUEST_FRAME;
  pReq->Request.ReportRouteInformation.ExpanderRouteIndex[0]=(nIndex&0xff00)>>8;
  pReq->Request.ReportRouteInformation.ExpanderRouteIndex[1]=nIndex&0xff;
  pReq->Request.ReportRouteInformation.PhyIdentifier=phyId;
  //MV_CopyMemory(pReq->Request.ReportRouteInformation. ,SasAddr,8);

  CORE_IssueSMPRequest ( PortExtension,
                         pParent->Info.SASAddr,
                         (MV_PVOID)pReq,
                         (void (*)(MV_PVOID DiscExtension, 
                                   MV_PVOID PortExtension, 
                                   MV_U8 *SasAddr, 
                                   MV_PVOID pSMPReq))SMP_Callback, 
                         pDISC_Extension );
}


MV_U16 CalculateRouteIndex(PDiscover_Extension pDisc, MV_PVOID pParent, MV_U8 PhyId)
{
  MV_U16 ReturnIndex;
  MV_U8 i; /*,j;*/

  ReturnIndex=0;

  for ( i=0;i< pDisc->TargetNumber; i++ )
  {
    if ( (pDisc->Target[i].pParent==pParent)&&
         (pDisc->Target[i].Info.ParentPhyId[0] < PhyId) )
    {
      ReturnIndex+=pDisc->Target[i].Info.PhyCount;
    }
  }
  return ReturnIndex;
}

MV_U32 FindFreeSMPContext(PDiscover_Extension pDisc)
{
	MV_U32 i;

	for ( i = 1; i<MAXIMUM_DISCOVER_REQUESTS; i++ )
	{
		if ( pDisc->SMPContext[i].isBufferFree == 1)
			return i;
	}
	return (0xffff);
}

MV_VOID FreeSMPContext(PDiscover_Extension pDisc, 
		                MV_U8 nTgt,
						MV_U8 nPhyId )
{
	MV_U32 i;

	for ( i = 1; i<MAXIMUM_DISCOVER_REQUESTS; i++ )
	{
		if ( (pDisc->SMPContext[i].nTgt == nTgt) &&
		     (pDisc->SMPContext[i].phyId == nPhyId) )
		{
			pDisc->SMPContext[i].isBufferFree = 1;
			MV_DPRINT (( "DISC: Buffer Id 0x%x is free\n", i));
			break;
		}
	}
}

MV_VOID DiscoverySM(MV_PVOID pDISC_Extension, 
		                MV_PVOID PortExtension, 
		                MV_U8 nTgt, 
		                MV_U8 CurrentState,
		                MV_U8 context,
		                MV_PVOID pBuffer)
{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;

  struct SMPResponse *pResp=(struct SMPResponse *)pBuffer;

  if ( pDisc->Target[nTgt].DiscoveryState==0xfd )
    CurrentState=0xfd;

  switch ( CurrentState )
  {
    case 0xff:
      pDisc->Target[nTgt].DiscoveryState=0xff;
      if ( pDisc->SMPContext[0].isBufferFree == 1 )
      {
        MV_DPRINT(( "DISC: Issue_ReportGeneral for Tgt 0x%x\n", nTgt));
        Issue_ReportGeneral ( pDISC_Extension, PortExtension, nTgt );
        pDisc->numOfOutstandingReq++;
      }
      else
      {
        /* For now, hold on DiscoverySM for this expander */
        pDisc->ExpandersTBD[nTgt] = 1;
        pDisc->PortExtensionsTBD[nTgt] = PortExtension;
      }
      break;

    case REPORT_GENERAL:
    {
      struct SMPResponse *pRepGenResp=(struct SMPResponse *)&pDisc->SMPContext[0].SMPBuffer;

      if ( pDisc->SMPContext[0].isBufferFree == 1 )
      {
        pDisc->Target[nTgt].Info.PhyCount=pRepGenResp->Response.ReportGeneral.NumberOfPhys;
        pDisc->Target[nTgt].NeedConfigured=pRepGenResp->Response.ReportGeneral.ConfigurableRouteTable;
        pDisc->Target[nTgt].DiscoveryState=REPORT_GENERAL;
        MV_DPRINT ( ( "DISC: Issue_ReportManufacturerInformation for Tgt 0x%x\n", nTgt) );
        Issue_ReportManufacturerInformation ( pDISC_Extension, PortExtension, nTgt );
        pDisc->numOfOutstandingReq++;
      }
      else
      {
        /* For now, hold on DiscoverySM for this expander */
        pDisc->ExpandersTBD[nTgt] = 1;
        pDisc->PortExtensionsTBD[nTgt] = PortExtension;
      }
      
      break;
    }

    case REPORT_MANUFACTURER_INFORMATION:
    {
      MV_U8 i;
      MV_U8 phyId = 0;
      struct SMPResponse *pRepMInfoResp=(struct SMPResponse *)&pDisc->SMPContext[0].SMPBuffer;

      pDisc->Target[nTgt].Info.ComponentRevisionID = 
        pRepMInfoResp->Response.ReportManufacturerInformation.ComponentRevisionID;
      MV_CopyMemory( & pDisc->Target[nTgt].Info.ComponentID, 
                     pRepMInfoResp->Response.ReportManufacturerInformation.ComponentID,2);
      MV_CopyMemory( pDisc->Target[nTgt].Info.ComponentVendorID, 
                     pRepMInfoResp->Response.ReportManufacturerInformation.ComponentVendorIdentification,8);
      MV_CopyMemory( pDisc->Target[nTgt].Info.VendorID, 
                     pRepMInfoResp->Response.ReportManufacturerInformation.VendorIdentification, 8);
      MV_CopyMemory( pDisc->Target[nTgt].Info.ProductID, 
                     pRepMInfoResp->Response.ReportManufacturerInformation.ProductIdentification, 16);
      MV_CopyMemory( pDisc->Target[nTgt].Info.ProductRev, 
                     pRepMInfoResp->Response.ReportManufacturerInformation.ProductRevisionLevel, 4);

      pDisc->Target[nTgt].DiscoveryState=REPORT_MANUFACTURER_INFORMATION;

      if ( pDisc->numOfOutstandingReq == (MAXIMUM_DISCOVER_REQUESTS-1) )
      {
        /* wait for completion of atleast one request */
        return;
      }

      while ( phyId < pDisc->Target[nTgt].Info.PhyCount )
      {
        /* we have atleast one buffer available */
        Issue_Discover ( pDISC_Extension, PortExtension, nTgt, phyId );
        phyId++;
        if ( phyId == pDisc->Target[nTgt].Info.PhyCount )
          pDisc->Target[nTgt].Info.phyIdToContinueDisc = 0;
        else
          pDisc->Target[nTgt].Info.phyIdToContinueDisc = phyId;
        if ( pDisc->numOfOutstandingReq == (MAXIMUM_DISCOVER_REQUESTS-1) )
        {
          /* save phyId to come back and continue discovery from there */
          break;
        }
      }
      
      pDisc->SMPContext[0].isBufferFree = 1; /* This Buffer is free now & can be reused */

      for ( i=0; i<pDisc->NumberOfMaxTarget; i++)
      {
        if ( pDisc->ExpandersTBD[i] == 1 )
        {
          pDisc->ExpandersTBD[i] = 0xff;
          DiscoverySM ( pDISC_Extension, pDisc->PortExtensionsTBD[i], i, 0xff, 0, NULL );
          break;
        }      
      }
      break;
    }

    case DISCOVER:
    {
      MV_U64 SasAddr;
      MV_U8 NewTgt = 0xff, ExistTgt = 0xff;
      MV_U8 i;

      MV_CopyMemory ( &SasAddr,pResp->Response.Discover.AttachedSASAddress,8 );
      U64_ASSIGN(SasAddr, MV_CPU_TO_BE64 ( SasAddr ));

      pDisc->Target[nTgt].DiscoveryState=DISCOVER;

      if ( pResp->Response.Discover.AttachedDeviceType!=NO_DEVICE )
      {
        if ( pDisc->Target[nTgt].pParent!=NULL )
        {
          if ( (!MV_Equals ( ((Discover_Target*)(pDisc->Target[nTgt].pParent))->Info.SASAddr, (MV_U8 *)&SasAddr, 8 ))&&
               (pResp->Response.Discover.TargetBits &
               (FRAME_ATT_DEV_TYPE_SSP | FRAME_ATT_DEV_TYPE_STP | FRAME_ATT_DEV_SATA_DEV | FRAME_ATT_DEV_TYPE_SMP)) )
          {
            Discover_Target *pTargetAncestry;
            /*
            ignore pointed back device 
            */
            pTargetAncestry=pDisc->Target[nTgt].pParent;
            while ( pTargetAncestry!=NULL )
            {
              if ( pTargetAncestry->NeedConfigured )
              {
                MV_U16 RouteIndex;
                if ( FindFreeSMPContext(pDisc)==0xffff )
                {
			/* need at least one more buffer for configure, otherwise re-do the discover*/	
                  FreeSMPContext(pDisc, nTgt,pResp->Response.Discover.PhyIdentifier); 
                  Issue_Discover ( pDISC_Extension, PortExtension, nTgt, pResp->Response.Discover.PhyIdentifier );

                  return;
                }
                RouteIndex=CalculateRouteIndex ( pDisc, pTargetAncestry, pDisc->Target[nTgt].Info.ParentPhyId[0] ) +
                                                 pResp->Response.Discover.PhyIdentifier;
                MV_DPRINT(( "DISC: Issue CONFIG_ROUTE for Tgt 0x%x\n", nTgt));
      

                Issue_ConfigRouteInfo ( pDISC_Extension, PortExtension, pTargetAncestry, 
                                        pDisc->Target[nTgt].Info.ParentPhyId[0], RouteIndex, 
                                        pResp->Response.Discover.AttachedSASAddress );

                pTargetAncestry=pTargetAncestry->pParent;
              }
              else
                pTargetAncestry=NULL;
            }
          }
        }
        if ( pResp->Response.Discover.TargetBits &
             (FRAME_ATT_DEV_TYPE_SSP |
             FRAME_ATT_DEV_TYPE_STP |
             FRAME_ATT_DEV_SATA_DEV) )
        {
          MV_U8 nDev;
          nDev = pDisc->Target[nTgt].Info.TotalDevCounts;
          if (pResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_SSP)
	          pDisc->Target[nTgt].TgtDev[nDev].Connection = DC_SCSI | DC_SERIAL;
          else 
	          pDisc->Target[nTgt].TgtDev[nDev].Connection = DC_SCSI | DC_SERIAL | DC_ATA;
          pDisc->Target[nTgt].TgtDev[nDev].DevType = DT_DIRECT_ACCESS_BLOCK;
          pDisc->Target[nTgt].TgtDev[nDev].TargetBits=pResp->Response.Discover.TargetBits;
          MV_CopyMemory ( pDisc->Target[nTgt].TgtDev[nDev].DevSASAddr,&SasAddr,8 );
          pDisc->Target[nTgt].TgtDev[nDev].PhyId = pResp->Response.Discover.PhyIdentifier;
          pDisc->Target[nTgt].TgtDev[nDev].NegotiatedLinkRate=
            MV_MIN ( pResp->Response.Discover.NegotiatedPhysicalLinkRate,pDisc->Target[nTgt].Info.NegotiatedLinkRate );
          /* Max linkrate can not be higher than the current path to the expander */
          pDisc->Target[nTgt].TgtDev[nDev].MaxLinkRateCapability=
            MV_MIN ( pResp->Response.Discover.HardwareMaximumPhysicalLinkRate,pDisc->Target[nTgt].Info.NegotiatedLinkRate );
          pDisc->Target[nTgt].Info.TotalDevCounts++;