[mirror_edk2.git] / EdkModulePkg / Universal / Network / Snp32_64 / Dxe / receive_filters.c

/*++\r
Copyright (c) 2006, Intel Corporation                                                         \r
All rights reserved. This program and the accompanying materials                          \r
are licensed and made available under the terms and conditions of the BSD License         \r
which accompanies this distribution.  The full text of the license may be found at        \r
http://opensource.org/licenses/bsd-license.php                                            \r
                                                                                          \r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
\r
Module name:\r
  receive_filters.c\r
\r
Abstract:\r
\r
Revision history:\r
  2000-Feb-17 M(f)J   Genesis.\r
--*/\r
\r
\r
#include "Snp.h"\r
\r
STATIC\r
EFI_STATUS\r
pxe_rcvfilter_enable (\r
  SNP_DRIVER      *snp,\r
  UINT32          EnableFlags,\r
  UINTN           MCastAddressCount,\r
  EFI_MAC_ADDRESS *MCastAddressList\r
  )\r
/*++\r
\r
Routine Description:\r
 this routine calls undi to enable the receive filters.\r
\r
Arguments:\r
  snp  - pointer to snp driver structure\r
  EnableFlags - bit mask for enabling the receive filters\r
  MCastAddressCount - multicast address count for a new multicast address list\r
  MCastAddressList  - list of new multicast addresses\r
\r
Returns:\r
\r
--*/\r
{\r
  snp->cdb.OpCode     = PXE_OPCODE_RECEIVE_FILTERS;\r
  snp->cdb.OpFlags    = PXE_OPFLAGS_RECEIVE_FILTER_ENABLE;\r
  snp->cdb.CPBsize    = PXE_CPBSIZE_NOT_USED;\r
  snp->cdb.DBsize     = PXE_DBSIZE_NOT_USED;\r
  snp->cdb.CPBaddr    = PXE_CPBADDR_NOT_USED;\r
  snp->cdb.DBaddr     = PXE_DBADDR_NOT_USED;\r
  snp->cdb.StatCode   = PXE_STATCODE_INITIALIZE;\r
  snp->cdb.StatFlags  = PXE_STATFLAGS_INITIALIZE;\r
  snp->cdb.IFnum      = snp->if_num;\r
  snp->cdb.Control    = PXE_CONTROL_LAST_CDB_IN_LIST;\r
\r
  if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_UNICAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_UNICAST;\r
  }\r
\r
  if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST;\r
  }\r
\r
  if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS;\r
  }\r
\r
  if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST;\r
  }\r
\r
  if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST;\r
  }\r
\r
  if (MCastAddressCount != 0) {\r
    snp->cdb.CPBsize  = (UINT16) (MCastAddressCount * sizeof (EFI_MAC_ADDRESS));\r
    snp->cdb.CPBaddr  = (UINT64) (UINTN) snp->cpb;\r
    CopyMem (snp->cpb, MCastAddressList, snp->cdb.CPBsize);\r
  }\r
  //\r
  // Issue UNDI command and check result.\r
  //\r
  DEBUG ((EFI_D_NET, "\nsnp->undi.receive_filters()  "));\r
\r
  (*snp->issue_undi32_command) ((UINT64) (UINTN) &snp->cdb);\r
\r
  if (snp->cdb.StatCode != EFI_SUCCESS) {\r
    //\r
    // UNDI command failed.  Return UNDI status to caller.\r
    //\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "\nsnp->undi.receive_filters()  %xh:%xh\n",\r
      snp->cdb.StatFlags,\r
      snp->cdb.StatCode)\r
      );\r
\r
    switch (snp->cdb.StatCode) {\r
    case PXE_STATCODE_INVALID_CDB:\r
    case PXE_STATCODE_INVALID_CPB:\r
    case PXE_STATCODE_INVALID_PARAMETER:\r
      return EFI_INVALID_PARAMETER;\r
\r
    case PXE_STATCODE_UNSUPPORTED:\r
      return EFI_UNSUPPORTED;\r
    }\r
\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
pxe_rcvfilter_disable (\r
  SNP_DRIVER *snp,\r
  UINT32     DisableFlags,\r
  BOOLEAN    ResetMCastList\r
  )\r
/*++\r
\r
Routine Description:\r
 this routine calls undi to disable the receive filters.\r
\r
Arguments:\r
  snp  - pointer to snp driver structure\r
  DisableFlags - bit mask for disabling the receive filters\r
  ResetMCastList - boolean flag to reset/delete the multicast filter list\r
\r
Returns:\r
\r
--*/\r
{\r
  snp->cdb.OpCode     = PXE_OPCODE_RECEIVE_FILTERS;\r
  snp->cdb.CPBsize    = PXE_CPBSIZE_NOT_USED;\r
  snp->cdb.DBsize     = PXE_DBSIZE_NOT_USED;\r
  snp->cdb.CPBaddr    = PXE_CPBADDR_NOT_USED;\r
  snp->cdb.DBaddr     = PXE_DBADDR_NOT_USED;\r
  snp->cdb.StatCode   = PXE_STATCODE_INITIALIZE;\r
  snp->cdb.StatFlags  = PXE_STATFLAGS_INITIALIZE;\r
  snp->cdb.IFnum      = snp->if_num;\r
  snp->cdb.Control    = PXE_CONTROL_LAST_CDB_IN_LIST;\r
\r
  snp->cdb.OpFlags    = (UINT16) (DisableFlags ? PXE_OPFLAGS_RECEIVE_FILTER_DISABLE : PXE_OPFLAGS_NOT_USED);\r
\r
  if (ResetMCastList) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST;\r
  }\r
\r
  if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_UNICAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_UNICAST;\r
  }\r
\r
  if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST;\r
  }\r
\r
  if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS;\r
  }\r
\r
  if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST;\r
  }\r
\r
  if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0) {\r
    snp->cdb.OpFlags |= PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST;\r
  }\r
  //\r
  // Issue UNDI command and check result.\r
  //\r
  DEBUG ((EFI_D_NET, "\nsnp->undi.receive_filters()  "));\r
\r
  (*snp->issue_undi32_command) ((UINT64) (UINTN) &snp->cdb);\r
\r
  if (snp->cdb.StatCode != EFI_SUCCESS) {\r
    //\r
    // UNDI command failed.  Return UNDI status to caller.\r
    //\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "\nsnp->undi.receive_filters()  %xh:%xh\n",\r
      snp->cdb.StatFlags,\r
      snp->cdb.StatCode)\r
      );\r
\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
pxe_rcvfilter_read (\r
  SNP_DRIVER *snp\r
  )\r
/*++\r
\r
Routine Description:\r
 this routine calls undi to read the receive filters.\r
\r
Arguments:\r
  snp  - pointer to snp driver structure\r
\r
Returns:\r
\r
--*/\r
{\r
  snp->cdb.OpCode   = PXE_OPCODE_RECEIVE_FILTERS;\r
  snp->cdb.OpFlags  = PXE_OPFLAGS_RECEIVE_FILTER_READ;\r
  snp->cdb.CPBsize  = PXE_CPBSIZE_NOT_USED;\r
  snp->cdb.DBsize   = (UINT16) (snp->mode.MaxMCastFilterCount * sizeof (EFI_MAC_ADDRESS));\r
  snp->cdb.CPBaddr  = PXE_CPBADDR_NOT_USED;\r
  if (snp->cdb.DBsize == 0) {\r
    snp->cdb.DBaddr = (UINT64) NULL;\r
  } else {\r
    snp->cdb.DBaddr = (UINT64) (UINTN) snp->db;\r
    ZeroMem (snp->db, snp->cdb.DBsize);\r
  }\r
\r
  snp->cdb.StatCode   = PXE_STATCODE_INITIALIZE;\r
  snp->cdb.StatFlags  = PXE_STATFLAGS_INITIALIZE;\r
  snp->cdb.IFnum      = snp->if_num;\r
  snp->cdb.Control    = PXE_CONTROL_LAST_CDB_IN_LIST;\r
\r
  DEBUG ((EFI_D_NET, "\nsnp->undi.receive_filters()  "));\r
\r
  (*snp->issue_undi32_command) ((UINT64) (UINTN) &snp->cdb);\r
\r
  if (snp->cdb.StatCode != EFI_SUCCESS) {\r
    //\r
    // UNDI command failed.  Return UNDI status to caller.\r
    //\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "\nsnp->undi.receive_filters()  %xh:%xh\n",\r
      snp->cdb.StatFlags,\r
      snp->cdb.StatCode)\r
      );\r
\r
    return EFI_DEVICE_ERROR;\r
  }\r
  //\r
  // Convert UNDI32 StatFlags to EFI SNP filter flags.\r
  //\r
  snp->mode.ReceiveFilterSetting = 0;\r
\r
  if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_UNICAST) != 0) {\r
    snp->mode.ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_UNICAST;\r
  }\r
\r
  if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_BROADCAST) != 0) {\r
    snp->mode.ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;\r
  }\r
\r
  if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_PROMISCUOUS) != 0) {\r
    snp->mode.ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;\r
  }\r
\r
  if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_ALL_MULTICAST) != 0) {\r
    snp->mode.ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;\r
  }\r
\r
  if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST) != 0) {\r
    snp->mode.ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST;\r
  }\r
\r
  CopyMem (snp->mode.MCastFilter, snp->db, snp->cdb.DBsize);\r
\r
  //\r
  // Count number of active entries in multicast filter list.\r
  //\r
  {\r
    EFI_MAC_ADDRESS ZeroMacAddr;\r
\r
    SetMem (&ZeroMacAddr, sizeof ZeroMacAddr, 0);\r
\r
    for (snp->mode.MCastFilterCount = 0;\r
         snp->mode.MCastFilterCount < snp->mode.MaxMCastFilterCount;\r
         snp->mode.MCastFilterCount++\r
        ) {\r
      if (CompareMem (\r
            &snp->mode.MCastFilter[snp->mode.MCastFilterCount],\r
            &ZeroMacAddr,\r
            sizeof ZeroMacAddr\r
            ) == 0) {\r
        break;\r
      }\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
snp_undi32_receive_filters (\r
  IN EFI_SIMPLE_NETWORK_PROTOCOL * this,\r
  IN UINT32                      EnableFlags,\r
  IN UINT32                      DisableFlags,\r
  IN BOOLEAN                     ResetMCastList,\r
  IN UINTN                       MCastAddressCount OPTIONAL,\r
  IN EFI_MAC_ADDRESS             * MCastAddressList OPTIONAL\r
  )\r
/*++\r
\r
Routine Description:\r
 This is the SNP interface routine for reading/enabling/disabling the\r
 receive filters.\r
 This routine basically retrieves snp structure, checks the SNP state and\r
 checks the parameter validity, calls one of the above routines to actually\r
 do the work\r
\r
Arguments:\r
  this  - context pointer\r
  EnableFlags - bit mask for enabling the receive filters\r
  DisableFlags - bit mask for disabling the receive filters\r
  ResetMCastList - boolean flag to reset/delete the multicast filter list\r
  MCastAddressCount - multicast address count for a new multicast address list\r
  MCastAddressList  - list of new multicast addresses\r
\r
Returns:\r
\r
--*/\r
{\r
  SNP_DRIVER  *snp;\r
  EFI_STATUS  Status;\r
\r
  if (this == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  snp = EFI_SIMPLE_NETWORK_DEV_FROM_THIS (this);\r
\r
  if (snp == NULL) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  switch (snp->mode.State) {\r
  case EfiSimpleNetworkInitialized:\r
    break;\r
\r
  case EfiSimpleNetworkStopped:\r
    return EFI_NOT_STARTED;\r
\r
  case EfiSimpleNetworkStarted:\r
    return EFI_DEVICE_ERROR;\r
\r
  default:\r
    return EFI_DEVICE_ERROR;\r
  }\r
  //\r
  // check if we are asked to enable or disable something that the UNDI\r
  // does not even support!\r
  //\r
  if ((EnableFlags &~snp->mode.ReceiveFilterMask) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((DisableFlags &~snp->mode.ReceiveFilterMask) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (ResetMCastList) {\r
    DisableFlags |= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST & snp->mode.ReceiveFilterMask;\r
    MCastAddressCount = 0;\r
    MCastAddressList  = NULL;\r
  } else {\r
    if (MCastAddressCount != 0) {\r
      if (MCastAddressCount > snp->mode.MaxMCastFilterCount) {\r
        return EFI_INVALID_PARAMETER;\r
      }\r
\r
      if (MCastAddressList == NULL) {\r
        return EFI_INVALID_PARAMETER;\r
      }\r
    }\r
  }\r
\r
  if (EnableFlags == 0 && DisableFlags == 0 && !ResetMCastList && MCastAddressCount == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0 && MCastAddressCount == 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((EnableFlags != 0) || (MCastAddressCount != 0)) {\r
    Status = pxe_rcvfilter_enable (\r
              snp,\r
              EnableFlags,\r
              MCastAddressCount,\r
              MCastAddressList\r
              );\r
\r
    if (Status != EFI_SUCCESS) {\r
      return Status;\r
    }\r
  }\r
\r
  if ((DisableFlags != 0) || ResetMCastList) {\r
    Status = pxe_rcvfilter_disable (snp, DisableFlags, ResetMCastList);\r
\r
    if (Status != EFI_SUCCESS) {\r
      return Status;\r
    }\r
  }\r
\r
  return pxe_rcvfilter_read (snp);\r
}\r
Commit	Line	Data
878ddf1f	1	/*++\r
	2	Copyright (c) 2006, Intel Corporation \r
	3	All rights reserved. This program and the accompanying materials \r
	4	are licensed and made available under the terms and conditions of the BSD License \r
	5	which accompanies this distribution. The full text of the license may be found at \r
	6	http://opensource.org/licenses/bsd-license.php \r
	7	\r
	8	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	9	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	10	\r
	11	Module name:\r
	12	receive_filters.c\r
	13	\r
	14	Abstract:\r
	15	\r
	16	Revision history:\r
	17	2000-Feb-17 M(f)J Genesis.\r
	18	--*/\r
	19	\r
	20	\r
4cbd855e	21	#include "Snp.h"\r
878ddf1f	22	\r
1cc8ee78	23	STATIC\r
878ddf1f	24	EFI_STATUS\r
	25	pxe_rcvfilter_enable (\r
	26	SNP_DRIVER *snp,\r
	27	UINT32 EnableFlags,\r
	28	UINTN MCastAddressCount,\r
	29	EFI_MAC_ADDRESS *MCastAddressList\r
	30	)\r
	31	/*++\r
	32	\r
	33	Routine Description:\r
	34	this routine calls undi to enable the receive filters.\r
	35	\r
	36	Arguments:\r
	37	snp - pointer to snp driver structure\r
	38	EnableFlags - bit mask for enabling the receive filters\r
	39	MCastAddressCount - multicast address count for a new multicast address list\r
	40	MCastAddressList - list of new multicast addresses\r
	41	\r
	42	Returns:\r
	43	\r
	44	--*/\r
	45	{\r
	46	snp->cdb.OpCode = PXE_OPCODE_RECEIVE_FILTERS;\r
	47	snp->cdb.OpFlags = PXE_OPFLAGS_RECEIVE_FILTER_ENABLE;\r
	48	snp->cdb.CPBsize = PXE_CPBSIZE_NOT_USED;\r
	49	snp->cdb.DBsize = PXE_DBSIZE_NOT_USED;\r
	50	snp->cdb.CPBaddr = PXE_CPBADDR_NOT_USED;\r
	51	snp->cdb.DBaddr = PXE_DBADDR_NOT_USED;\r
	52	snp->cdb.StatCode = PXE_STATCODE_INITIALIZE;\r
	53	snp->cdb.StatFlags = PXE_STATFLAGS_INITIALIZE;\r
	54	snp->cdb.IFnum = snp->if_num;\r
	55	snp->cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST;\r
	56	\r
	57	if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_UNICAST) != 0) {\r
	58	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_UNICAST;\r
	59	}\r
	60	\r
	61	if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST) != 0) {\r
	62	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST;\r
	63	}\r
	64	\r
	65	if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) != 0) {\r
	66	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS;\r
	67	}\r
	68	\r
	69	if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {\r
	70	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST;\r
	71	}\r
	72	\r
	73	if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0) {\r
	74	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST;\r
	75	}\r
	76	\r
	77	if (MCastAddressCount != 0) {\r
	78	snp->cdb.CPBsize = (UINT16) (MCastAddressCount * sizeof (EFI_MAC_ADDRESS));\r
	79	snp->cdb.CPBaddr = (UINT64) (UINTN) snp->cpb;\r
	80	CopyMem (snp->cpb, MCastAddressList, snp->cdb.CPBsize);\r
	81	}\r
	82	//\r
	83	// Issue UNDI command and check result.\r
	84	//\r
	85	DEBUG ((EFI_D_NET, "\nsnp->undi.receive_filters() "));\r
	86	\r
	87	(*snp->issue_undi32_command) ((UINT64) (UINTN) &snp->cdb);\r
88	\r
89	if (snp->cdb.StatCode != EFI_SUCCESS) {\r
90	//\r
91	// UNDI command failed. Return UNDI status to caller.\r
92	//\r
93	DEBUG (\r
94	(EFI_D_ERROR,\r
95	"\nsnp->undi.receive_filters() %xh:%xh\n",\r
96	snp->cdb.StatFlags,\r
97	snp->cdb.StatCode)\r
98	);\r
99	\r
100	switch (snp->cdb.StatCode) {\r
101	case PXE_STATCODE_INVALID_CDB:\r
102	case PXE_STATCODE_INVALID_CPB:\r
103	case PXE_STATCODE_INVALID_PARAMETER:\r
104	return EFI_INVALID_PARAMETER;\r
105	\r
106	case PXE_STATCODE_UNSUPPORTED:\r
107	return EFI_UNSUPPORTED;\r
108	}\r
109	\r
110	return EFI_DEVICE_ERROR;\r
111	}\r
112	\r
113	return EFI_SUCCESS;\r
114	}\r
115	\r
1cc8ee78	116	STATIC\r
878ddf1f	117	EFI_STATUS\r
	118	pxe_rcvfilter_disable (\r
	119	SNP_DRIVER *snp,\r
	120	UINT32 DisableFlags,\r
	121	BOOLEAN ResetMCastList\r
	122	)\r
	123	/*++\r
	124	\r
	125	Routine Description:\r
	126	this routine calls undi to disable the receive filters.\r
	127	\r
	128	Arguments:\r
	129	snp - pointer to snp driver structure\r
	130	DisableFlags - bit mask for disabling the receive filters\r
	131	ResetMCastList - boolean flag to reset/delete the multicast filter list\r
	132	\r
	133	Returns:\r
	134	\r
	135	--*/\r
	136	{\r
	137	snp->cdb.OpCode = PXE_OPCODE_RECEIVE_FILTERS;\r
	138	snp->cdb.CPBsize = PXE_CPBSIZE_NOT_USED;\r
	139	snp->cdb.DBsize = PXE_DBSIZE_NOT_USED;\r
	140	snp->cdb.CPBaddr = PXE_CPBADDR_NOT_USED;\r
	141	snp->cdb.DBaddr = PXE_DBADDR_NOT_USED;\r
	142	snp->cdb.StatCode = PXE_STATCODE_INITIALIZE;\r
	143	snp->cdb.StatFlags = PXE_STATFLAGS_INITIALIZE;\r
	144	snp->cdb.IFnum = snp->if_num;\r
	145	snp->cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST;\r
	146	\r
	147	snp->cdb.OpFlags = (UINT16) (DisableFlags ? PXE_OPFLAGS_RECEIVE_FILTER_DISABLE : PXE_OPFLAGS_NOT_USED);\r
	148	\r
	149	if (ResetMCastList) {\r
	150	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_RESET_MCAST_LIST;\r
	151	}\r
	152	\r
	153	if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_UNICAST) != 0) {\r
	154	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_UNICAST;\r
	155	}\r
	156	\r
	157	if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST) != 0) {\r
	158	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST;\r
	159	}\r
	160	\r
	161	if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) != 0) {\r
	162	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS;\r
	163	}\r
	164	\r
	165	if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {\r
	166	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST;\r
	167	}\r
	168	\r
	169	if ((DisableFlags & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0) {\r
	170	snp->cdb.OpFlags \|= PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST;\r
	171	}\r
	172	//\r
	173	// Issue UNDI command and check result.\r
	174	//\r
	175	DEBUG ((EFI_D_NET, "\nsnp->undi.receive_filters() "));\r
	176	\r
	177	(*snp->issue_undi32_command) ((UINT64) (UINTN) &snp->cdb);\r
	178	\r
	179	if (snp->cdb.StatCode != EFI_SUCCESS) {\r
	180	//\r
181	// UNDI command failed. Return UNDI status to caller.\r
182	//\r
183	DEBUG (\r
184	(EFI_D_ERROR,\r
185	"\nsnp->undi.receive_filters() %xh:%xh\n",\r
186	snp->cdb.StatFlags,\r
187	snp->cdb.StatCode)\r
188	);\r
189	\r
190	return EFI_DEVICE_ERROR;\r
191	}\r
192	\r
193	return EFI_SUCCESS;\r
194	}\r
195	\r
1cc8ee78	196	STATIC\r
878ddf1f	197	EFI_STATUS\r
	198	pxe_rcvfilter_read (\r
	199	SNP_DRIVER *snp\r
	200	)\r
	201	/*++\r
	202	\r
	203	Routine Description:\r
	204	this routine calls undi to read the receive filters.\r
	205	\r
	206	Arguments:\r
	207	snp - pointer to snp driver structure\r
	208	\r
	209	Returns:\r
	210	\r
	211	--*/\r
	212	{\r
	213	snp->cdb.OpCode = PXE_OPCODE_RECEIVE_FILTERS;\r
	214	snp->cdb.OpFlags = PXE_OPFLAGS_RECEIVE_FILTER_READ;\r
	215	snp->cdb.CPBsize = PXE_CPBSIZE_NOT_USED;\r
	216	snp->cdb.DBsize = (UINT16) (snp->mode.MaxMCastFilterCount * sizeof (EFI_MAC_ADDRESS));\r
	217	snp->cdb.CPBaddr = PXE_CPBADDR_NOT_USED;\r
	218	if (snp->cdb.DBsize == 0) {\r
	219	snp->cdb.DBaddr = (UINT64) NULL;\r
	220	} else {\r
	221	snp->cdb.DBaddr = (UINT64) (UINTN) snp->db;\r
	222	ZeroMem (snp->db, snp->cdb.DBsize);\r
	223	}\r
	224	\r
	225	snp->cdb.StatCode = PXE_STATCODE_INITIALIZE;\r
	226	snp->cdb.StatFlags = PXE_STATFLAGS_INITIALIZE;\r
	227	snp->cdb.IFnum = snp->if_num;\r
	228	snp->cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST;\r
	229	\r
	230	DEBUG ((EFI_D_NET, "\nsnp->undi.receive_filters() "));\r
	231	\r
	232	(*snp->issue_undi32_command) ((UINT64) (UINTN) &snp->cdb);\r
	233	\r
	234	if (snp->cdb.StatCode != EFI_SUCCESS) {\r
	235	//\r
	236	// UNDI command failed. Return UNDI status to caller.\r
	237	//\r
	238	DEBUG (\r
	239	(EFI_D_ERROR,\r
	240	"\nsnp->undi.receive_filters() %xh:%xh\n",\r
	241	snp->cdb.StatFlags,\r
	242	snp->cdb.StatCode)\r
	243	);\r
	244	\r
	245	return EFI_DEVICE_ERROR;\r
	246	}\r
	247	//\r
	248	// Convert UNDI32 StatFlags to EFI SNP filter flags.\r
	249	//\r
	250	snp->mode.ReceiveFilterSetting = 0;\r
	251	\r
	252	if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_UNICAST) != 0) {\r
	253	snp->mode.ReceiveFilterSetting \|= EFI_SIMPLE_NETWORK_RECEIVE_UNICAST;\r
	254	}\r
	255	\r
	256	if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_BROADCAST) != 0) {\r
	257	snp->mode.ReceiveFilterSetting \|= EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;\r
	258	}\r
	259	\r
	260	if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_PROMISCUOUS) != 0) {\r
261	snp->mode.ReceiveFilterSetting \|= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;\r
262	}\r
263	\r
264	if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_ALL_MULTICAST) != 0) {\r
265	snp->mode.ReceiveFilterSetting \|= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;\r
266	}\r
267	\r
268	if ((snp->cdb.StatFlags & PXE_STATFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST) != 0) {\r
269	snp->mode.ReceiveFilterSetting \|= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST;\r
270	}\r
271	\r
272	CopyMem (snp->mode.MCastFilter, snp->db, snp->cdb.DBsize);\r
273	\r
274	//\r
275	// Count number of active entries in multicast filter list.\r
276	//\r
277	{\r
278	EFI_MAC_ADDRESS ZeroMacAddr;\r
279	\r
280	SetMem (&ZeroMacAddr, sizeof ZeroMacAddr, 0);\r
281	\r
282	for (snp->mode.MCastFilterCount = 0;\r
283	snp->mode.MCastFilterCount < snp->mode.MaxMCastFilterCount;\r
284	snp->mode.MCastFilterCount++\r
285	) {\r
286	if (CompareMem (\r
287	&snp->mode.MCastFilter[snp->mode.MCastFilterCount],\r
288	&ZeroMacAddr,\r
289	sizeof ZeroMacAddr\r
290	) == 0) {\r
291	break;\r
292	}\r
293	}\r
294	}\r
295	\r
296	return EFI_SUCCESS;\r
297	}\r
298	\r
299	EFI_STATUS\r
300	EFIAPI\r
301	snp_undi32_receive_filters (\r
302	IN EFI_SIMPLE_NETWORK_PROTOCOL * this,\r
303	IN UINT32 EnableFlags,\r
304	IN UINT32 DisableFlags,\r
305	IN BOOLEAN ResetMCastList,\r
306	IN UINTN MCastAddressCount OPTIONAL,\r
307	IN EFI_MAC_ADDRESS * MCastAddressList OPTIONAL\r
308	)\r
309	/*++\r
310	\r
311	Routine Description:\r
312	This is the SNP interface routine for reading/enabling/disabling the\r
313	receive filters.\r
314	This routine basically retrieves snp structure, checks the SNP state and\r
315	checks the parameter validity, calls one of the above routines to actually\r
316	do the work\r
317	\r
318	Arguments:\r
319	this - context pointer\r
320	EnableFlags - bit mask for enabling the receive filters\r
321	DisableFlags - bit mask for disabling the receive filters\r
322	ResetMCastList - boolean flag to reset/delete the multicast filter list\r
323	MCastAddressCount - multicast address count for a new multicast address list\r
324	MCastAddressList - list of new multicast addresses\r
325	\r
326	Returns:\r
327	\r
328	--*/\r
329	{\r
330	SNP_DRIVER *snp;\r
331	EFI_STATUS Status;\r
332	\r
333	if (this == NULL) {\r
334	return EFI_INVALID_PARAMETER;\r
335	}\r
336	\r
337	snp = EFI_SIMPLE_NETWORK_DEV_FROM_THIS (this);\r
338	\r
339	if (snp == NULL) {\r
340	return EFI_DEVICE_ERROR;\r
341	}\r
342	\r
343	switch (snp->mode.State) {\r
344	case EfiSimpleNetworkInitialized:\r
345	break;\r
346	\r
347	case EfiSimpleNetworkStopped:\r
348	return EFI_NOT_STARTED;\r
349	\r
350	case EfiSimpleNetworkStarted:\r
351	return EFI_DEVICE_ERROR;\r
352	\r
353	default:\r
354	return EFI_DEVICE_ERROR;\r
355	}\r
356	//\r
357	// check if we are asked to enable or disable something that the UNDI\r
358	// does not even support!\r
359	//\r
360	if ((EnableFlags &~snp->mode.ReceiveFilterMask) != 0) {\r
361	return EFI_INVALID_PARAMETER;\r
362	}\r
363	\r
364	if ((DisableFlags &~snp->mode.ReceiveFilterMask) != 0) {\r
365	return EFI_INVALID_PARAMETER;\r
366	}\r
367	\r
368	if (ResetMCastList) {\r
369	DisableFlags \|= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST & snp->mode.ReceiveFilterMask;\r
370	MCastAddressCount = 0;\r
371	MCastAddressList = NULL;\r
372	} else {\r
373	if (MCastAddressCount != 0) {\r
374	if (MCastAddressCount > snp->mode.MaxMCastFilterCount) {\r
375	return EFI_INVALID_PARAMETER;\r
376	}\r
377	\r
378	if (MCastAddressList == NULL) {\r
379	return EFI_INVALID_PARAMETER;\r
380	}\r
381	}\r
382	}\r
383	\r
384	if (EnableFlags == 0 && DisableFlags == 0 && !ResetMCastList && MCastAddressCount == 0) {\r
385	return EFI_SUCCESS;\r
386	}\r
387	\r
388	if ((EnableFlags & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0 && MCastAddressCount == 0) {\r
389	return EFI_INVALID_PARAMETER;\r
390	}\r
391	\r
392	if ((EnableFlags != 0) \|\| (MCastAddressCount != 0)) {\r
393	Status = pxe_rcvfilter_enable (\r
394	snp,\r
395	EnableFlags,\r
396	MCastAddressCount,\r
397	MCastAddressList\r
398	);\r
399	\r
400	if (Status != EFI_SUCCESS) {\r
401	return Status;\r
402	}\r
403	}\r
404	\r
405	if ((DisableFlags != 0) \|\| ResetMCastList) {\r
406	Status = pxe_rcvfilter_disable (snp, DisableFlags, ResetMCastList);\r
407	\r
408	if (Status != EFI_SUCCESS) {\r
409	return Status;\r
410	}\r
411	}\r
412	\r
413	return pxe_rcvfilter_read (snp);\r
414	}\r