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