core_ibcd.c

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

#include "core_header.h"
#include "core_ibcd.h"

/*
  Core Driver will provide the following functions to call:
*/
/* tell core driver to issue a SMP command from a dedicated port/expander */
extern MV_VOID CORE_IssueSMPRequest(IN MV_PVOID PortExtension, IN MV_U8 *SasAddr, IN MV_PVOID pSMPReq, IN void (*pCallBack)(MV_PVOID pDISC_Extension, MV_PVOID PortExtension, IN MV_U8 *SasAddr, MV_PVOID pSMPReq), MV_PVOID Context);		

/* tell core driver to get port sas address and root expander sas address from a dedicated port */
extern MV_VOID CORE_GetPortAddress(IN MV_PVOID PortExtension, OUT MV_U8 *SasAddr);

struct _Discover_Extension;
typedef struct _Discover_Extension Discover_Extension, *PDiscover_Extension;

struct _SMPBuffer_Context;
typedef struct _SMPBuffer_Context SMPBuffer_Context, *PSMPBuffer_Context;

struct _SMPBuffer_Context
{
  PDiscover_Extension pDiscExt;
  struct SMPRequest SMPBuffer;
  MV_U8  nTgt;
  MV_U8  phyId;
  MV_U8  BufferIndex;
  MV_U8  isBufferFree;
};

typedef struct _Discover_PortInfo
{
  MV_PVOID    PortExtension;
  MV_U8       DiscoveryReturn;
}Discover_PortInfo, *pDiscover_PortInfo;

typedef struct _Discover_Target
{
  Target_Info       Info;
  MV_U8			        DiscoveryState;
  MV_U8			        NeedConfigured;
  MV_PVOID		      pParent;
  MV_PVOID		      PCallBack;
  MV_PVOID          PortExtension;
  Target_Dev	      TgtDev[MAXIMUM_DEVICE_PER_EXPANDER];
}Discover_Target, *pDiscover_Target;

struct _Discover_Extension
{
  MV_U32            ExtensionSize;
  MV_U8			        NumberOfMaxTarget;
  MV_U8			        TargetNumber;
  MV_U8			        numOfOutstandingReq;
  MV_U8             ExpandersTBD[MAX_EXPANDER_SUPPORTED_PERFORMANCE];
  MV_PVOID          PortExtensionsTBD[MAX_EXPANDER_SUPPORTED_PERFORMANCE];
  Discover_PortInfo PortInfo[MAX_PHYSICAL_PORT_NUMBER];
  SMPBuffer_Context	SMPContext[MAXIMUM_DISCOVER_REQUESTS];
  Discover_Target	  Target[0];
};


/*
  Discover Engine will provide the following functions to call:
*/


/* Get cached memory quota of discover engine for internal use */
MV_VOID DISC_GetResource(OUT MV_U32 *Size, IN MV_U8 MaxTgt, IN MV_U16 MaxDev)
{
  *Size = sizeof(Discover_Extension) + MaxTgt*sizeof(Discover_Target);
}


/* Give assigned memory pointer and size for discover engine */
MV_VOID DISC_SetResource(IN MV_PVOID pDISC_Extension, IN MV_U32 Size)
{
  MV_U8 i;
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;

  MV_ZeroMemory ( pDISC_Extension, Size );
  pDisc->ExtensionSize=Size;
  pDisc->NumberOfMaxTarget=(MV_U8)( (Size-sizeof(Discover_Extension))/sizeof(Discover_Target) );

  for ( i=0; i< pDisc->NumberOfMaxTarget; i++)
  {
    pDisc->ExpandersTBD[i] = 0xff;
    pDisc->Target[i].DiscoveryState = 0xfd;
  }
  pDisc->numOfOutstandingReq = 0;
  pDisc->TargetNumber = 0;
  for ( i=0; i < MAXIMUM_DISCOVER_REQUESTS; i++ )
  {
    pDisc->SMPContext[i].isBufferFree = 1;
    pDisc->SMPContext[i].BufferIndex = i;
  }
}


MV_U8	FindTgtNo(
	IN MV_PVOID pDISC_Extension,
	IN MV_U8 *SasAddr)
{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;
  MV_U8 i;

  for ( i=0; i<pDisc->NumberOfMaxTarget; i++ )
  {
    if ( (pDisc->Target[i].DiscoveryState!=0xfd)&&
		 (MV_Equals ( pDisc->Target[i].Info.SASAddr, SasAddr, 8 )) )
      return i;
  }
  return 0xff;
}


MV_VOID DiscoverySM(MV_PVOID pDISC_Extension, MV_PVOID PortExtension, MV_U8 nTgt, MV_U8 CurrentState, MV_U8 context, 
                    MV_PVOID pResp);


static void SMP_Callback(
	IN MV_PVOID pDISC_Extension, 
	IN MV_PVOID PortExtension, 
	IN MV_U8 *SasAddr, 
	IN MV_PVOID pSMPReq	 
	)
{
  PDiscover_Extension pDisc;
  MV_U8 nTgt;
  MV_U8 i;
  struct SMPResponse *pSMPResp;
  pSMPResp= (struct SMPResponse *)pSMPReq;

  if ( pSMPResp->Function == CONFIGURE_ROUTE_INFORMATION )
  {
    pDisc = ((PSMPBuffer_Context)pDISC_Extension)->pDiscExt;
  }
  else
  {
    pDisc=(PDiscover_Extension)pDISC_Extension;
  }
  
  /* Might be a callback from a previous discovery cycle */
  if ( pDisc->numOfOutstandingReq == 0 )
    return;

  nTgt=FindTgtNo ( pDisc, SasAddr );
  if ( nTgt==0xff )
    return;

  MV_DPRINT (( "DISC: SMP Function 0x%x Done For Port(0x%p).Target 0x%02x%02x%02x%02x%02x%02x%02x%02x Result 0x%x\n", 
              pSMPResp->Function, 
              PortExtension, 
              SasAddr[7],
              SasAddr[6],
              SasAddr[5],
              SasAddr[4],
              SasAddr[3],
              SasAddr[2],
              SasAddr[1],
              SasAddr[0],
              pSMPResp->FunctionResult ));

  switch ( pSMPResp->Function )
  {
    case REPORT_GENERAL:
      if ( pDisc->SMPContext[0].isBufferFree == 0 )
      {
        pDisc->SMPContext[0].isBufferFree = 1;
        pDisc->numOfOutstandingReq--;
        MV_DPRINT (( "DISC: Number of Phy 0x%x\n", 
          pSMPResp->Response.ReportGeneral.NumberOfPhys ));
        MV_DPRINT (( "DISC: Virtual Phy Id 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[0],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[1],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[2],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[3],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[4],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[5],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[6],
          pSMPResp->Response.ReportGeneral.EnclosureLogicalIdentifier[7] ));
        MV_DPRINT (( "DISC: Need Configured 0x%x\n", 
          pSMPResp->Response.ReportGeneral.ConfigurableRouteTable ));
        MV_DPRINT (( "DISC: Max Route Entry 0x%02x%02x\n", 
          pSMPResp->Response.ReportGeneral.MaxNumRoutedSASAddr[0],
          pSMPResp->Response.ReportGeneral.MaxNumRoutedSASAddr[1] ));
        DiscoverySM ( pDISC_Extension,PortExtension,nTgt,REPORT_GENERAL, 0, NULL );
      }
      else
      {
        /* Might be a callback from a previous discovery cycle */
        return;  
      }
      break;
    case REPORT_MANUFACTURER_INFORMATION:
      if ( pDisc->SMPContext[0].isBufferFree == 0 )
      {
        pDisc->SMPContext[0].isBufferFree = 1;
        pDisc->numOfOutstandingReq--;
        MV_DPRINT (( "DISC: Manufacturer Vendor ID 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[0],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[1],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[2],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[3],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[4],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[5],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[6],
          pSMPResp->Response.ReportManufacturerInformation.VendorIdentification[7] ));
        MV_DPRINT (( "DISC: Manufacturer Product ID %s\n", 
          pSMPResp->Response.ReportManufacturerInformation.ProductIdentification ));
        DiscoverySM ( pDISC_Extension,PortExtension,nTgt,REPORT_MANUFACTURER_INFORMATION, 0, NULL );
      }
      else
      {
        /* Might be a callback from a previous discovery cycle */
        return;  
      }

      break;
    //	case READ_GPIO_REGISTER:
    //						break;
    case REPORT_SELF_CONFGRIGRUATION_STATUS:
      break;
    case DISCOVER:
      for ( i = 1; i<MAXIMUM_DISCOVER_REQUESTS; i++ )
      {
        if ( (pDisc->SMPContext[i].nTgt == nTgt) &&
             (pDisc->SMPContext[i].phyId == pSMPResp->Response.Discover.PhyIdentifier) )
        {
          break;
        }
      }
      pDisc->numOfOutstandingReq--;
      MV_DPRINT (( "DISC: Discover Response for Tgt 0x%x in Buffer 0x%x\n", nTgt, i));
      MV_DPRINT (( "DISC: Phy ID 0x%x\n", 
        pSMPResp->Response.Discover.PhyIdentifier ));
      MV_DPRINT (( "DISC: SAS Address 0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 
        pSMPResp->Response.Discover.AttachedSASAddress[0],
        pSMPResp->Response.Discover.AttachedSASAddress[1],
        pSMPResp->Response.Discover.AttachedSASAddress[2],
        pSMPResp->Response.Discover.AttachedSASAddress[3],
        pSMPResp->Response.Discover.AttachedSASAddress[4],
        pSMPResp->Response.Discover.AttachedSASAddress[5],
        pSMPResp->Response.Discover.AttachedSASAddress[6],
        pSMPResp->Response.Discover.AttachedSASAddress[7] ));
      MV_DPRINT (( "DISC: Device Type 0x%x\n", 
        pSMPResp->Response.Discover.AttachedDeviceType ));
      MV_DPRINT (( "DISC: Target %s%s%s\n", 
        (pSMPResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_SSP)?"SSP ":"",
        (pSMPResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_SMP)?"SMP ":"",
        (pSMPResp->Response.Discover.TargetBits & FRAME_ATT_DEV_TYPE_STP)?"STP ":"" ));
      DiscoverySM ( pDISC_Extension,PortExtension,nTgt,DISCOVER,pSMPResp->Response.Discover.PhyIdentifier, pSMPResp );
      break;
    case REPORT_PHY_ERROR_LOG:
      break;
    case REPORT_PHY_SATA:
      break;
    case REPORT_ROUTE_INFORMATION:
      break;
    case REPORT_PHY_EVENT_INFORMATION:
      break;
    case REPORT_PHY_BROADCAST_COUNTS:
      break;
    case DISCOVER_LIST:
      break;
    case REPORT_EXPANDER_ROUTE_TABLE:
      break;
    case CONFIGURE_GENERAL:
      break;
    case ENABLE_DISABLE_ZONING:
      break;
    //	case WRITE_GPIO_REGISTER:
    //						break;
    case ZONED_BROADCAST:
      break;
    case CONFIGURE_ROUTE_INFORMATION:
    {
      SMPBuffer_Context* pSMPBuff;
      pSMPBuff = (SMPBuffer_Context *)pDISC_Extension;
      
      pDisc->SMPContext[pSMPBuff->BufferIndex].isBufferFree = 1;
      pDisc->numOfOutstandingReq--;
      DiscoverySM ( (MV_PVOID)pDisc,PortExtension,nTgt,CONFIGURE_ROUTE_INFORMATION,0, 0 );
        
    }
      break;
    case PHY_CONTROL:
      break;
    case PHY_TEST:
      break;
    case CONFIGURE_PHY_EVENT_INFORMATION:
      break;
  }
}

void Issue_ReportGeneral(
	IN MV_PVOID pDISC_Extension, 
	IN MV_PVOID PortExtension, 
	IN MV_U8 nTgt	
	)
{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;
  /* Report General always uses Buffer index 0 */
  struct SMPRequest *pReq= (struct SMPRequest*)&pDisc->SMPContext[0].SMPBuffer;

  pDisc->SMPContext[0].isBufferFree = 0;
  MV_ZeroMemory ( pReq, sizeof(struct SMPRequest) );
  pReq->Function=REPORT_GENERAL;
  pReq->SMPFrameType=SMP_REQUEST_FRAME;

  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 );
}


void Issue_ReportManufacturerInformation(
	IN MV_PVOID pDISC_Extension, 
	IN MV_PVOID PortExtension, 
	IN MV_U8 nTgt	
	)
{
  PDiscover_Extension pDisc=(PDiscover_Extension)pDISC_Extension;
  /* Report Manufacturer Info always uses Buffer index 0 */
  struct SMPRequest *pReq= (struct SMPRequest*)&pDisc->SMPContext[0].SMPBuffer;

  pDisc->SMPContext[0].isBufferFree = 0;
  MV_ZeroMemory ( pReq, sizeof(struct SMPRequest) );
  pReq->Function=REPORT_MANUFACTURER_INFORMATION;
  pReq->SMPFrameType=SMP_REQUEST_FRAME;

  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 );
}


void Issue_Discover(
	IN MV_PVOID pDISC_Extension, 
	IN MV_PVOID PortExtension, 
	IN MV_U8 nTgt,
	IN MV_U8 PhyId
	)