EdkModulePkg/Universal/Network/Snp32_64/Dxe/receive_filters.c

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